Check whether the gma3_mcp_bridge plugin inside grandMA3 onPC is reachable and report software version, show file, user, the Lua execution policy (whether gma3_lua is enabled on the console and its per-request time/instruction budget), the configured OSC fallback, and whether this server build matches its source checkout (server.build.state 'stale' means tools added or changed since the build are missing or out of date).

Fallback for when the bridge is not running: sends the command Plugin "gma3_mcp_bridge" to onPC over OSC (/cmd). Requires the OSC configuration in onPC (Menu > In & Out > OSC) to have Enable Input on and Receive Command = Yes on a line matching GMA3_OSC_PORT (gma3_osc shows it; gma3_test_osc_input proves it). Then waits briefly and pings the bridge.

FALLBACK for a command no structured tool covers: patching, looks, presets, groups, phasers, cues, chases and playback have their own tools (see the server instructions), which check before acting and read back; a raw command is not checked or read back. Execute a grandMA3 command-line command exactly as it would be typed (without Please/Enter). Examples: "Go+ Sequence 1", "Fixture 1 Thru 10 At 50", "Store Cue 2 /Merge /NoConfirmation", "ClearAll", "FaderMaster Page 1.201 At 75 Fade 2". Returns the command line feedback (OK, Syntax Error, Illegal Command). Commands that produce output (List, GetGlobalVariable, etc.) print to the console history, not here; use gma3_get_object / gma3_list_children to read data. $variables expand in commands sent through the bridge, outside quotes (SU-15 probe: Label Sequence 940 $name named the sequence after the variable); a user variable shadows a global one, and a command with a missing $variable does nothing. Read and set them with gma3_variables / gma3_set_variable. Via "osc" the command is sent fire-and-forget over OSC and no feedback is available.

FALLBACK: use a structured tool when one fits; they check, read back and need no Lua. Patch: gma3_patch_library, gma3_patch_import, gma3_patch_add, gma3_patch_set, gma3_patch_move, gma3_patch_stages, gma3_patch_retype, gma3_patch_type_structure, gma3_place_fixtures, gma3_layout_cells. Dialogs: gma3_dialog (never Mouse()). Groups: gma3_store_group, gma3_configure_matricks. Presets: gma3_apply_preset, gma3_store_preset. Phasers: gma3_build_phaser. Looks: gma3_set_attributes. Cues: gma3_store_cues, gma3_edit_cues, gma3_build_chase, gma3_cue_contents. Recipe cues: gma3_store_recipe_cues, then gma3_cook_recipes. Playback: gma3_configure_sequence, gma3_configure_executor, gma3_playback, gma3_goto_cue. Reads: gma3_objects, gma3_get_object, gma3_list_children, gma3_programmer; used and free pool numbers and executors: gma3_pool_usage. Many objects at once: gma3_store_group (groups), gma3_store_preset (presets, each from explicit content), gma3_store_macro (macros), gma3_edit_macro_line (edits), gma3_assign_to_executor (assignments), gma3_configure_sequence (sequences, with ranges), gma3_set_variable (variables), gma3_store_cues (sequences), gma3_store_tag (tags), gma3_delete_tag (tags), gma3_assign_tag (assignments), gma3_configure_tag (tags) take lists with per-item checks and read-back; never loop over them in Lua. Watching over time: gma3_observe_tempo (how fast running sequences (chases) advance), gma3_observe_values (programmer or DMX output values of fixtures as they change), gma3_build_chase (one cycle of the chase it built), gma3_run_macro (a macro's running line), gma3_timecode_transport (a timecode show's cursor and the sequences it fires). They sample server-side; never write a Lua waiting or polling loop (gma3_lua has a 5 s budget). Evaluate Lua 5.4 code inside the grandMA3 Lua engine and return the result(s) as JSON. The code is first compiled as an expression ('return '), then as a statement block. All grandMA3 Lua API functions are available (Cmd, ObjectList, DataPool, Root, ShowData, Patch, Programmer, SelectedSequence, GetCurrentCue, GetExecutor, GetVar/SetVar, Printf, Echo, Enums, ...). Object handles are returned as {name, class, addr, addrNative, index, childCount}; use handle:Get('Prop') to read properties, :Children(), :Count(), :Ptr(i). Examples: 'SelectedSequence().name', 'GetCurrentCue():Get("No")', 'DataPool().Sequences:Count()', 'local t={} for i,c in ipairs(ObjectList("Fixture Thru")) do t[#t+1]=c.name end return t'. Use gma3_lua_api to look up function signatures. This capability is OFF by default on the console: the operator enables it by starting the bridge with Plugin "gma3_mcp_bridge" "lua" or running Plugin "gma3_mcp_bridge" "lua on" (gma3_status shows the policy). Each request runs under the console's execution budget (default 5 s wall-clock / 20 M VM instructions, operator-configurable) and is aborted with an error when it exceeds it, so keep scripts short and prefer the structured tools (gma3_get_object, gma3_list_children, gma3_objects) for bulk reads. By default the console's own hook on the plugin thread is preserved, which means the instruction budget is NOT enforced and the deadline is only checked when the script yields or returns: a script that loops without yielding cannot be stopped (gma3_status shows lua.bounded; the result's budget.instructionHookEnforced says what applied). The operator can start the bridge with luahook=replace to enforce hard quotas. Because a script may call Cmd() or Set(), every gma3_lua request is serialised with this server's other mutations (it waits for a running workflow and blocks later ones while it runs).

Search the live grandMA3 Lua API descriptor (function name, arguments, return values) for both object-free functions (Cmd, ObjectList, …) and object methods (Get, Children, SetFader, …). Leave query empty to list everything.

Read an object from the show data: name, class, address, all properties (as display text), optionally the property schema and a listing of its children. Use this to inspect sequences, cues, executors, fixtures, presets, groups, macros, pages, settings, etc. TAGS reads as a list of {tag, name, protect} (bridge 0.36.0; gma3_tags lists the tags and the objects that carry them).

List the children of an object (e.g. cues of a sequence, items of a pool, executors of a page) with name, class, address and index, plus optional property values per child. Paginated: truncated: true (with a note) when more children follow. For the used and free numbers of a pool use gma3_pool_usage.

Resolve a command-line object range to a list of objects with optional property values. Examples: "Fixture 1 Thru 20", "Fixture Thru" (all fixtures), "Group Thru", "Sequence 1 Thru 10", "Preset 4.1 Thru 20", "Page 1.201 Thru 1.215". "Preset 4.1 Thru 4.20" and "Preset 4.1 + 21.2" need bridge 0.46.0 (an older bridge returns nothing for them; a range across pools is refused).

Return the raw grandMA3 Dump() text for an object: class, path, every property and child. Verbose; prefer gma3_get_object for structured data.

Set a property of a show object via the Lua Set() API, e.g. ref 'Sequence 1', property 'Name' or 'Tracking'; ref 'Sequence 1 Cue 2', property 'TrigTime'. Values are passed as text the way they would be typed in the editor (e.g. 'Yes', 'No', '2.5', 'Follow'). This modifies the show file. The property and the object's Lock and SystemLocked are read before the write; the console keeps the old value without an error when it does not take one. The result's verification is 'verified' only for plain values that read back as requested: Yes/No (its spellings only on a Yes/No property), enums, numbers (by the raw value), and text compared exactly, spaces included. 'failed' (an error): the value is still the old one (naming the lock, Unlock then set then Lock again, or saying the lock state is unknown), another plain value, or the read-back failed. 'unverified' (not an error): object references (Appearance, ...), a macro line's Command and Wait, Tags, durations and other values the console reformats are not judged; the read-back is returned with a hint naming the typed tool that checks it (gma3_get_object, gma3_macros / gma3_edit_macro_line, gma3_tags).

Trigger a playback function on a sequence or executor. Equivalent to commands like 'Go+ Sequence 1', 'Off Executor 201', 'Load Sequence 1 Cue 5'. Targets: 'Sequence 3', 'Executor 201', 'Page 2.201', 'Sequence 1 Cue 4' (for load/go to a cue), 'Master 3.1', 'Macro 5', 'Group 2'. For a Sequence or Executor target the playback state is read back a frame after the command (playbackState: active, currentCue {no, name}, or lastCue after Off; needs bridge 0.32.0 for the cue). A tag target ('Tag 5' or 'Tag "Encore"') reaches every sequence the tag carries when its Forward Commands is on: the tag is resolved first (an unknown tag or a name more than one tag has sends nothing), the command addresses it by number, and each tagged sequence's state is read back (playbackState.sequences; bridge 0.36.0). resync: ReSync for 'Sequence 1', 'Sequence 1 + 11 Thru 19' (every sequence must exist; each one's state is read back) or an executor. ReSync gradually moves the start point of the phasers running in the sequences to the moment of the command (the console's manual: it synchronizes phasers gradually, it does not jump). It does not restart the sequence or change its cue.

Set a fader of a playback object (sequence, executor's assigned object, master) to a value 0..100 via the Lua SetFader API. Tokens: FaderMaster (default), FaderX, FaderXA, FaderXB, FaderTemp, FaderRate, FaderSpeed, FaderHighlight, FaderLowlight, FaderTime, FaderSolo. For a timed fade use gma3_command with e.g. 'FaderMaster Sequence 1 At 50 Fade 3'.

Read fader values and display text of a playback object (sequence, master, executor's object).

List all sequences in the selected data pool with cue count, whether they have active playback, and the current cue (currentCue {no, name} while it plays; lastCue: the cue it stopped in, after Off). Needs bridge 0.32.0 for the cue.

List the cues of one sequence (sequence) or several (sequences, up to 20) with cue number, name, trigger (TrigType, TrigTime) and command, plus each sequence's playback state (playback: active, currentCue {no, name} while it plays, lastCue after Off; bridge 0.32.0).

List executors on the current executor page with their assigned object, key/fader functions and master fader level, and for an assigned sequence its playback state (assigned.currentCue {no, name} while it plays, assigned.lastCue after Off; bridge 0.32.0). Executor numbers: 101-115 top row, 201-215 faders, 301-315 etc.

List fixtures in the patch with ID, name, fixture type and DMX patch. Paginated; use filter to restrict (e.g. 'Fixture 1 Thru 50').

List the objects of a pool in the selected data pool: Sequences, Groups, Presets (pool name like 'Presets' lists preset pools; use 'Preset 4' style ref via gma3_list_children for one pool), Macros, Pages, Worlds, Filters, Timecodes, Timers, Layouts, Views, Appearances, MAtricks, Plugins, Cameras, Sounds, ScreenConfigurations, Agendas, Images, Videos, Scribbles, Gels, Datapools.

Look up a topic in the grandMA3 user manual shipped with onPC. Pass a command keyword (e.g. 'Go', 'Store', 'Assign', 'SendOSC', 'Lua', 'At', 'Fade') or a topic phrase (e.g. 'osc', 'cue timing', 'phaser'). Uses the versioned indexed corpus when GMA3_DOCS_URL is configured, otherwise the installed manual. Returns source-linked text or matching canonical identities; source examples are never executed.

Select fixtures by range or group in the programmer. Sends the selection expression as a command (e.g. Fixture 1 Thru 5, Group 3). CHANGES THE SELECTION: grandMA3 adds to the current selection when it has no active values and replaces it when values are active; set clear_first to send ClearSelection first for a deterministic result. Does NOT clear programmer values (ClearSelection only deselects). Verifies that Selection.CountTotalSelected is >= 1 afterwards and lists the selected members (first 50) for information; it does not assert exact membership. Serialised against this server's other mutations only, not against other operators or clients.

Set one attribute (Dimmer, Pan, Zoom, ColorRGB_R, ...) to an absolute value in the programmer. Sends Attribute "<name>" At Absolute [<unit keyword>] <value> after establishing the target. Target is explicit: fixtures (range/group) OR use_selection: true. With fixtures the tool sends ClearSelection and then SELECTS exactly those fixtures (the selection changes; previously selected fixtures are not affected unless add_to_selection is true). Never clears programmer values. Without unit the number is interpreted by the user profile's readout. Small explicit targets are pre-checked against the fixture type's attribute list (check_attributes), and after setting, the programmer is read back and compared per fixture in the unit sent (verify); a fixture without the attribute is a mismatch, not a success. Serialised against this server's other mutations only.

Set ColorRGB_R, ColorRGB_G and ColorRGB_B (each 0..100 %) in the programmer: three commands Attribute "ColorRGB_R" At Absolute Percent <r> etc., stopping at the first the console rejects (partial result). Target is explicit: fixtures OR use_selection: true. With fixtures the tool sends ClearSelection and then SELECTS exactly those fixtures (the selection changes; previously selected fixtures are not affected unless add_to_selection is true). Never clears programmer values. Only the documented ColorRGB_* attributes are supported. Small explicit targets are pre-checked against the fixture type's attributes (check_attributes); after setting, the programmer is read back and each fixture's R, G and B are compared in percent (verify), so a fixture without RGB is a mismatch, not a success. Serialised against this server's other mutations only.

Set Pan and/or Tilt in the programmer with explicit units: unit "degrees" sends Attribute "Pan" At Absolute Physical <v>, unit "percent" sends ... At Absolute Percent <v> (0..100). Pan first, then Tilt; stops at the first rejected command. Target is explicit: fixtures OR use_selection: true. With fixtures the tool sends ClearSelection and then SELECTS exactly those fixtures (the selection changes; previously selected fixtures are not affected unless add_to_selection is true). Never clears programmer values. Small explicit targets are pre-checked against the fixture type's attributes (check_attributes); after setting, the programmer is read back and Pan/Tilt are compared per fixture in the unit sent, converting degrees through each fixture's physical range (verify). A fixture without Pan/Tilt is a mismatch, not a success. Serialised against this server's other mutations only.

Explicit clear with a required mode: "selection" sends ClearSelection (deselects fixtures, keeps all programmer values); "active" sends ClearActive (deactivates values, keeps selection and values); "all" sends ClearAll (clears the selection AND discards every programmer value). Nothing is implied: one command per call. Verifies Selection.CountTotalSelected == 0 for selection/all; programmer values cannot be read back (unavailable for active). Serialised against this server's other mutations only.

Set a whole look on one target in one call: intensity (At <value>, percent) and/or several attributes, each Attribute "<name>" At Absolute [<unit keyword>] <value>, in the order given. Stops at the first command the console rejects (partial result). Target is explicit: fixtures OR use_selection: true; with fixtures, ClearSelection and then a select (see gma3_set_attribute). Never clears programmer values. Note: setting one colour attribute activates the fixture's whole colour group in the programmer (the other mix channels at their defaults), so the programmer can hold more rows than attributes sent. Small explicit targets are pre-checked against the fixture types' attributes (check_attributes); the programmer is read back and every targeted fixture (and cell) is compared per attribute in the unit sent (verify), as gma3_set_attribute does. Serialised against this server's other mutations only.

Recall a stored preset into the programmer for an explicit target: At Preset <pool>.<number> (or a preset by name). Target: fixtures OR use_selection: true (with fixtures, ClearSelection and a select first). Pre-checks (nothing sent on failure): the preset exists, and the target is not empty. Both matter: the console answers OK and changes nothing for a missing preset or an empty selection. A preset applies to every fixture that has its attributes, whatever type it was stored from. Read-back: every selected fixture (or its cells) must hold programmer values linked to the preset (the channel's preset link; needs bridge 0.27.0); a fixture the preset holds nothing for is a mismatch. Never clears programmer values.

Remove values from the programmer for an explicit target: attributes sends Off Attribute "A" + "B"; all: true sends Off Attribute Thru (every value of the target, the cells of a compound fixture included; the target stays selected). Target: fixtures OR use_selection: true (with fixtures, ClearSelection and a select first). The release is scoped to the selection, and with nothing selected the console would release the attributes from EVERY fixture, so the tool refuses unless the target is selected. Read-back compares the whole programmer before and after: the released values must be gone from the target fixtures and their cells, and every other fixture's values must be unchanged.

Read the Layout pool or one layout in an explicit data pool using children/objects/object. Returns bounded element pages, current element numbers, GUID identities, assigned object handles and geometry, action, appearance, custom text and visibility fields. schema optionally returns the layout's live property schema. Read-only; no selection, programmer, playback or Viewer window changes. An incomplete page is explicitly flagged; read all pages before planning a broad edit.

Apply up to 100 explicit element edits in one existing layout and required data pool. Add requires integer x/y/width/height in layout units; positions are Int16 and dimensions 1..32767. Update/remove require the current element number and GUID from gma3_layouts; stale/duplicate identities, locks and read-only properties are refused. Never clears/rebuilds the layout. Add sends Store Layout n.k /NoConfirmation to append a blank element; assignment uses set Object with a resolved numeric address, never Assign At Layout n.k (which appends). Remove sends Delete Layout n.k /NoConfirmation for the confirmed GUID. Other supplied fields use one set each. Object assignment accepts Macro/Sequence/Group; replacing a different assignment requires replace_object:true. Actions are validated for the actual assigned object class. Appearance overrides use a global Appearance pool number, resolved and verified by encoded handle/address. Custom text preserves case, quotes and internal spaces; leading/trailing whitespace is refused because read-only bridge fields trim it. Custom text accepts RGBA hex colour, captured font-size enums and alignment; visibility accepts Visible/Hidden. Reads GUIDs and typed object handles separately, and verifies identities, supplied properties and object addresses after edits; visual rendering and actual action execution are not verified. Does not select fixtures, clear programmer values, invoke layout elements, or execute assigned macros or sequences. Uses existing bridge operations without Lua, OSC fallback or automatic replay. Preview reads and validates without mutations. Mutations are serialised within this server, without isolation from another operator or client. Every property write requires read-back; uncertain writes stop the plan and require inspection before retrying. Layout Viewer window setup, grid and fit settings are outside this tool.

Create a new empty layout or update only supplied layout fields in an explicit data pool. Create refuses an occupied number; names are checked against the pool. Sends Store Layout n /NoConfirmation only for create, then one set request per supplied field, followed by objects read-back. It never deletes or rebuilds elements. Canvas coordinates and dimensions use integer layout units; position/size are Int16, view coordinates Int32, view scale a positive ratio (0.8 = 80%; console read-back displays percent). Verifies existence and supplied fields, not rendered appearance. Does not select fixtures, clear programmer values, invoke layout elements, or execute assigned macros or sequences. Uses existing bridge operations without Lua, OSC fallback or automatic replay. Preview reads and validates without mutations. Mutations are serialised within this server, without isolation from another operator or client. Every property write requires read-back; uncertain writes stop the plan and require inspection before retrying. Layout Viewer window setup, grid and fit settings are outside this tool.

Store the programmer content as a cue of a sequence (create, merge or overwrite), optionally with a name and cue timing (seconds). Sends one Store command (/NoConfirmation; /Merge or /Overwrite for those modes), then one Set() per given name/timing field on the part (part 0 for a cue): Name, CueInFade (fade), CueInDelay (delay), CueOutFade, CueOutDelay. Mode create first checks that the target does not exist and refuses (nothing sent) if it does; that check is a point-in-time read, not a transaction lock. The current fixture selection is not changed; the programmer is not cleared (no Clear is sent). Reads back existence, Name and the timing fields that were given; the store step and the read-back are reported separately. Stored fixture values (attribute data) are NOT verified; that needs gma3_cue_contents (FR-10). The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

Store the programmer content into a part of a cue (Store Sequence n Cue c Part p). Part 0 is the main part that every cue has, so storing to part 0 is the same as storing the cue; parts 1..999 hold values with their own timing. Sends one Store command (/NoConfirmation; /Merge or /Overwrite for those modes), then one Set() per given name/timing field on the part (part 0 for a cue): Name, CueInFade (fade), CueInDelay (delay), CueOutFade, CueOutDelay. Mode create first checks that the target does not exist and refuses (nothing sent) if it does; that check is a point-in-time read, not a transaction lock. The current fixture selection is not changed; the programmer is not cleared (no Clear is sent). Reads back existence, Name and the timing fields that were given; the store step and the read-back are reported separately. Stored fixture values (attribute data) are NOT verified; that needs gma3_cue_contents (FR-10). The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

Edit the timing of an existing cue part (default part 0, the cue's main part) with one Set() per given field: fade (CueInFade), delay (CueInDelay), out_fade (CueOutFade), out_delay (CueOutDelay), snap_delay (SnapDelay), all in seconds; 0 is a value. Only the given fields are changed. Refuses (nothing sent) when the cue part does not exist. No command-line command is sent; selection and programmer are untouched. Reads the changed fields back from the part. Stored fixture values are not touched or verified. The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

Set how an existing cue is triggered: trigger "go" (manual), "time" (after time seconds; time required), "follow" (when the previous cue completes; optional time as extra delay), "sound" or "bpm" (no time). Sets the cue's TrigType and then TrigTime via Set(); no command-line command is sent, selection and programmer are untouched. Refuses (nothing sent) when the cue does not exist. Reads TrigType and TrigTime back. The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

PLAYBACK MUTATION: sends Goto Sequence n Cue c [Fade s], which jumps the sequence to that cue and changes live output. Goto is a playback mutation. The sequence's current cue is read back a frame after the command; the crossfade runs asynchronously and its completion is not verified. Refuses (nothing sent) when the cue does not exist. Does not change the selection or the programmer. Verification: matched when the sequence plays that cue a frame later (playbackState has the cue's number and name; needs bridge 0.32.0). The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

Delete exactly one explicit cue with Delete Sequence n Cue c /NoConfirmation. Ranges (Thru, +) are rejected. Checks the cue exists first and refuses (nothing sent) when it does not. Verifies by reading existence back: matched when gone, mismatched when it still exists, unavailable when unreadable. Does not change the selection or the programmer. Never retried. The mutation lock orders only this server's own mutations; it does not isolate the operation from another console operator or another client.

Assign a sequence or macro to an executor on an explicit page: give sequence for compatibility or object (Sequence , Macro , optionally DataPool ). Sends 'Assign At Page .'. Before sending anything it checks read-only that the sequence and the page exist and what the executor currently holds; an executor holding a different object is only replaced with replace: true (otherwise the call fails with the previous assignment in the result), and an executor that already holds this sequence is left alone (alreadyAssigned: true, no command sent). Optional label: sends 'Label Page . ""' after assigning. On grandMA3 an executor has no label of its own: it shows its assigned object's name, so this RENAMES THE ASSIGNED OBJECT itself, everywhere it appears (pools, other executors). If labelling fails after the assignment the outcome is partial. Does not change the fixture selection or the programmer and never sends Go/On/Off/Toggle or any playback keyword; whether the console changes the selected sequence on assignment is not controlled by this tool. verify (default true) reads the executor back and compares the assigned object by address, name and class and, when a label was given, the executor's displayed name and the object's own Name; executor configuration, fader/key functions and playback state are NOT verified. Mutations from this server are serialised, but another operator or client can still change the executor between the inspection and the assignment. Batch form (assignments): each target executor is checked to be empty or to hold that sequence already, unless replace is given for that item (or for the whole call); a target listed twice is refused. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Label the object assigned to the executor at Page .: sends 'Label Page . ""'. On grandMA3 2.5.1 an executor has no label of its own and always shows its assigned object's name, so this RENAMES THE ASSIGNED SEQUENCE (or other object) everywhere it appears: in its pool and on every other executor it is assigned to. Fails before sending anything when the page does not exist or the executor is empty (nothing to label). Does not change the selection or the programmer and never sends a playback keyword. verify (default true) reads back the executor's displayed name and assigned object and the assigned object's own Name; nothing else is verified. Mutations from this server are serialised, but not isolated from other operators or clients.

List the attributes of one fixture or subfixture with stable identifiers (attribute name, attributeIndex, uiChannel), pretty name, feature/feature group, activation group, physical unit, natural readout, the channel function's DMX and physical ranges, defaults, optional channel sets, and the DMX address mapping (coarse/fine/ultra as universe.address) from the RT channels. Subfixtures of a compound fixture are listed explicitly (subfixtures[], with their patch index); pass Fixture 501.3 to inspect one. Works with gma3_lua disabled (structured bridge op, plugin >= 0.3.0). Read-only: never changes selection, programmer or playback. The fixture is resolved by fixture ID through the console (patch index is reported separately as subfixtureIndex, never assumed equal). source says whether rows came from the UI channel API ("uiChannels") or the static fixture-type walk ("fixtureTypeWalk", no uiChannel). Null fields were not supplied by the console (explicitly unavailable, never inferred). Results are paginated. Not available: current values (use gma3_programmer / gma3_fixture_output).

Structured view of active programmer values per UI channel (fixture, subfixture patch index, attribute, value, timing, phaser steps). Scope is explicit: all (every patched (sub)fixture, including unselected ones), selection (SelectionTable) or fixtures (an explicit range). Works with gma3_lua disabled (structured bridge op, plugin >= 0.3.0). Read-only: never changes selection, programmer or playback. ROWS ARE PROGRAMMER CONTENT, NOT OUTPUT VALUES (source "programmer"; use gma3_fixture_output/gma3_dmx for output). A row is emitted only when the console's activity masks show programmer data; value: 0 with present: true is a real zero, an absent row means no programmer value. Multi-step phasers keep every step in steps[] (value is null) with phaser-level fade/delay/speed/phase; phaser.supported is false with a reason when the API shape was unusable. coverage reports whether the scan was complete; when it is not (budget reached, API unavailable) the programmer is NOT claimed empty. Paginated. value is percent, valueRaw the 24-bit integer. Compact form: fields keeps only those row keys; by_fixture: true gives perFixture, one entry per fixture, with attribute -> value (a multi-step phaser reads "phaser (n steps)"). To watch values change over time use gma3_observe_values.

Current DMX output of one fixture or subfixture per RT channel: channel name, attribute, universe.address, raw value (8-bit per address, combined to 16/24-bit when fine/ultra addresses exist; bits and unit say which), derived percent, and where the fixture type's channel function is known a physical value (conversion: "linear from channel function") and the active channel set. Works with gma3_lua disabled (structured bridge op, plugin >= 0.3.0). Read-only: never changes selection, programmer or playback. Source is "dmx output": these are output levels, NOT programmer values. Not available: per-attribute cooked output (the API has none), values on a universe that is not granted on this onPC (value null plus a limitation, and outputState explains each such universe: not granted, or not sent by any protocol; gma3_dmx_output has the whole picture). nonzero_only is an explicit filter (default false). Paginated.

Raw DMX output for an explicit universe and channel range (channels 1..512; universe 1..1024, further bounded by the console's universe count). unit is explicit: "raw8" (0..255 per address) or "percent" (0..100 as the console converts it). Works with gma3_lua disabled (structured bridge op, plugin >= 0.3.0). Read-only: never changes selection, programmer or playback. Source is "dmx output": output levels, NOT programmer values. A universe that is not granted on this onPC returns no values with granted: false, a limitation (never zeros) and outputState explaining why (gma3_dmx_output has the whole picture). The range is from..to, or from plus count addresses (one of to or count; neither reads the one address from). nonzero_only (also accepted as nonzeroOnly, the result's spelling) is an explicit filter. patched: true additionally maps each returned address to its fixture/channel through the RT channels (bounded; stated in limitations when skipped). 16-bit attributes appear as two separate 8-bit addresses.

Read what a cue stores without playing it back or loading it: cue properties (No, Name, TrigType, TrigTime, TrigSound, Release, Assert, Note), per part the timing (CueFade, CueDelay, CueInFade, CueInDelay, CueOutFade, CueOutDelay, SnapDelay), command, MIB settings, OwnDataPresent, and the recipes (selection, preset text plus the resolved preset reference or an explicit unresolved marker, values, FadeX/DelayX/SpeedX/PhaseX, enabled). expand_presets: true adds the referenced presets' data (GetPresetData) keyed by preset address. Works with gma3_lua disabled (structured bridge op, plugin >= 0.3.0). Read-only: never changes selection, programmer or playback. SUPPORTED MODE (onPC 2.5.1): recipe- and preset-based content only. NOT AVAILABLE: hard (non-recipe) fixture values stored in a part (storedValues is always null; a limitation is added when OwnDataPresent is Yes) and tracked/effective values (trackedValues: "not_reconstructed"; a part lists only what it stores). The fixtures filter applies to expanded preset data only (stated in limitations). Never sends Goto, Load or any playback command.

Explicit ownership for console key input across several calls (KB-05). acquire returns a leased interaction id bound to this server's bridge connection; pass it to gma3_hardkey/gma3_keyboard press and release, gma3_type and gma3_input_sequence. While it is open the bridge refuses commands, property changes, playback, faders and Lua from EVERY client with [busy] (reads stay available), so end it as soon as the interaction is done. renew moves the lease deadline (default 15 s, max 120 s; nothing is pressed). end releases every key the interaction holds (newest first), aborts its sequence and reports what stayed unresolved. An interaction is never resumed: after a lease expiry, a bridge reconnect or end, acquire a new one. Needs input enabled on the console (Plugin "gma3_mcp_bridge" "input=keyboard"); end works while input is disabled. Nothing here presses a key.

Press, release or tap a logical MA hardkey (PLEASE, STORE, ESC, CLEAR, OOPS, NUM0-9, EXEC with executor, MA) on the console through the bridge's keyboard backend: REAL console keys are pressed through the operator's shortcut table or a verified native route (MA = LeftShift, PLEASE = Enter redirect); unmapped, ambiguous or colliding routes are refused before dispatch. tap presses and releases with hold_ms (default 50, max 5000) and returns once the release was attempted; exclusive: true is the intended long-press (every other input is refused meanwhile). On the Quickey backend a tap of a code with direct-tap evidence, without exclusive and with hold_ms 50 or less, is one Press Quickey (nothing held; KB-29, bridge 0.37.0). keys (2-4 logical keys) presses a combination in order and releases newest first (chord tap with action tap; a hold with action press). press holds the key until release or the interaction/lease ends and REQUIRES an interaction id (gma3_input_interaction acquire). While any key is held, an interaction is open or a release stayed unresolved, the bridge refuses commands/property/playback/fader/Lua from every client with [busy]. Input is OFF until the operator runs Plugin "gma3_mcp_bridge" "input=keyboard" (release works while off). Input is not display-scoped. The result never claims a UI effect: verification is unavailable unless an observable (aggregate MASTATE for MA) showed the expected value; a release on this backend is 'dispatched', never 'confirmed'. Nothing is retried or replayed; an uncertain dispatch is reported as unknown.

Press, release or tap a raw PC key (case-sensitive Enums.KeyboardCodes name: Enter, Escape, F1, 5, A, LeftShift ...) with shift/ctrl/alt/numlock passed explicitly on the press AND the release, through the console's Keyboard() emulation. What the key does depends on the operator's user profile, keyboard shortcut enablement and the focused UI element (a mapped key may edit a focused field instead of acting as a hardkey); nothing is substituted or resolved for you, prefer gma3_hardkey for MA keys. tap returns after the release was attempted; press REQUIRES an interaction id; release uses the stored press tuple. Same gate, ownership, busy and verification rules as gma3_hardkey: real keys, input OFF until the operator runs Plugin "gma3_mcp_bridge" "input=keyboard", not display-scoped, commands from every client are [busy] while a key is held, UI effect unverified, nothing retried or replayed.

Type Unicode text as one character event per code point into an EXPLICIT context. Which element receives characters cannot be observed from Lua, so acknowledge_focus: true is always required: you state that the command line (context 'command-line') or a text field (context 'text-field') is focused. 'command-line' is admitted only while the operator has disabled keyboard shortcuts (F10; with shortcuts enabled, characters never reach the command line and nothing is substituted) and is read back from the command line: matched when it shows the text; when it does not within the readback window the step is UNKNOWN and nothing after it runs. 'text-field' cannot be read back (verification unavailable) and must not be followed by PLEASE/Enter in the same sequence. Text is refused while an exclusive long-press is held or a held key's route changed. Text is typed in chunks by the bridge loop with the context rechecked between chunks; it stops with its progress (unknown) when shortcuts are toggled, a route changes or a long-press starts meanwhile. Newlines, tabs and other control characters are refused (up to 256 characters); text NEVER presses Enter, changes focus, opens an editor or toggles shortcuts: commit it with a separate gma3_hardkey PLEASE tap. Same gate and busy rules as gma3_hardkey (input OFF until the operator runs Plugin "gma3_mcp_bridge" "input=keyboard"; commands from every client are [busy] while it types). Nothing is retried or replayed; a character whose dispatch raised is reported as unknown at that position.

Run an ordered, bounded sequence of console input under one interaction owner: taps, presses, releases, combinations, text and waits (at most 16 steps, about 30 s of holds/waits/typing). The bridge validates EVERY step (routes, keys, text policy, context) before the first event; one invalid step means nothing is dispatched. Steps are then serviced one after another by the plugin loop (a tap waits for its release, text goes out in chunks with its context rechecked), and a failure stops the sequence: later steps are reported as skipped, keys the sequence still holds are released newest first, nothing is replayed. Each step ends succeeded, failed (nothing of it dispatched), unknown (a dispatch raised or a release stayed unresolved: the console may have received it) or skipped. A tap is complete only after its release was attempted; completed never means a UI effect was verified (see verification/readback). Pass interaction to run inside an acquired interaction, otherwise one is begun and ended for the sequence. Commands from every client are [busy] while it runs. Input is OFF until the operator runs Plugin "gma3_mcp_bridge" "input=keyboard". Real console keys are pressed.

Read-only: whether console input is enabled and on which backend (keyboard = real keys, fake = nothing reaches the console), the backend's limitations, this server's session, every ownership record (owner, logical key, stored PC tuple, state, lease and deadline, dispatch outcomes, aggregate MASTATE readback, unresolved cleanup failures), open interactions, the running or last sequence, capacity, and the busy descriptor the bridge applies to commands. Ownership records are responsibility for recovery, not physical key state (injected and physical input share one key state). Works while input is disabled; releases nothing.

Release every key held by this server's bridge session, newest first, with the stored press tuples (never re-resolved), and with recover: true also re-attempt the releases that stayed unresolved (a remapped or disabled shortcut, a release that raised). Works while input is disabled: this is the recovery path. A release on the keyboard backend is 'dispatched' (no per-key readback), an unresolved one is reported as unknown and stays as a record until it succeeds or the operator runs Plugin "gma3_mcp_bridge" "input recover". Only this server's keys are affected; another client's or a physical operator's keys are not.

Read-only console state for feedback (KB-06): command-line text, last command feedback, Blind/Highlight/Solo, Preview mode, a display's Preview bar, keyboard-shortcut enablement, aggregate MA state, current executor page, selected sequence, and per executor the assignment and fader level, per sequence its playback activity. Works with gma3_lua disabled, with console input disabled and while another client holds an input interaction; it acquires nothing and changes no console state (selection, command line, programmer, playback, focus). Every item carries available, value (null when unavailable, with a reason or error; false is an observed value), scope, source, observedAt and epoch. Items are read one after another, not as an atomic snapshot. lastCommand and maState are shared observations, not confirmation of a request or key owner; sequenceActive is playback activity, not executor button state; Freeze has no readable state and is always unavailable. With no arguments every parameterless reader is read (previewBar on display 1). Bridge op feedback.read (plugin >= 0.8.0).

Read-only. Lists the fixture types imported into the show with their DMX modes: number, name, manufacturer, short name, source, and per mode the DMX footprint, the number of DMX breaks, the channels per break and the number of cells (bridge 0.28.0; null on older plugins; a mode with cells patches fixtures whose cells are selectable sub-fixtures). gma3_patch_type_structure lists a mode's channels, cells and geometry. Use the type and mode numbers or names with gma3_patch_add. Only the show's own types are listed: find a fixture in the console's library with gma3_patch_library and add it to the show with gma3_patch_import.

Read-only. Lists the show's fixtures from the live patch, every stage, sub-fixtures included, in patch order. Each fixture has FID, CID, ID type, name, fixture type, mode, patch address, DMX breaks, stage, depth, parent FID, subfixtures (child fixtures of a grouping fixture) and cells (the fixture's own cells, e.g. 12 on a 12-cell wall washer; bridge 0.28.0). Filter by FID range (fromFid/toFid; fixtures without a numeric FID are omitted when a range is given); paginated (limit default 200, max 2000).

Add count fixtures of one fixture type and DMX mode at consecutive FIDs from fid, patched consecutively from a DMX address (address, or the first free block found from findFreeFrom), or unpatched when neither is given. Pre-checks (nothing sent on failure): the FIDs are free, the whole block is free and fits inside one universe, the mode has a single DMX break. Fixtures are added at the top level of a stage (default: the first stage). Runs one patch session through the patch edit copy, never a dialog: read-only pre-checks (command line at Root, the copy closed, so nobody is in the Patch menu, no modal open, plus the tool's own checks), then enter the copy, apply the change there, an isolation check, commit, and read back. Requires exclusive: true. Patch changes need exclusive use of the console: the isolation check compares fingerprints of the copy and the live patch, left out the touched FIDs, over several seconds. It is best-effort detection of someone else's changes, not a guarantee, and on a mismatch nothing is committed and the copy is left open for the operator. A committed patch change has NO UNDO (Oops does not revert it). Takes about 10 s (mostly the isolation check). When a session cannot be finished, the copy is closed again only if it provably holds no change; otherwise the result says copyLeftOpen: true and the command line stays inside the edit patch with no Patch window open: the operator keeps the copy by typing ChangeDestination Root at the console (no way to discard it without the Patch menu is known). Needs bridge 0.19.0; a session in a stage with a Name needs bridge 0.45.0. verify reads the new FIDs back: present, patch addresses, name (when given) and mode. With count above 1 a clean success lists each new fixture as {fid, name, address} in items (detail: true for the full rows).

Change existing fixtures: per edit, a new DMX address (address), unpatch: true, and/or a new name. Addresses are applied together, so fixtures can swap addresses or move across their own current range. Pre-checks (nothing sent on failure): every FID exists, single-break modes only, and the new ranges overlap no other patched fixture. In the copy the bridge re-checks and restores every change of the call on any problem. Runs one patch session through the patch edit copy, never a dialog: read-only pre-checks (command line at Root, the copy closed, so nobody is in the Patch menu, no modal open, plus the tool's own checks), then enter the copy, apply the change there, an isolation check, commit, and read back. Requires exclusive: true. Patch changes need exclusive use of the console: the isolation check compares fingerprints of the copy and the live patch, left out the touched FIDs, over several seconds. It is best-effort detection of someone else's changes, not a guarantee, and on a mismatch nothing is committed and the copy is left open for the operator. A committed patch change has NO UNDO (Oops does not revert it). Takes about 10 s (mostly the isolation check). When a session cannot be finished, the copy is closed again only if it provably holds no change; otherwise the result says copyLeftOpen: true and the command line stays inside the edit patch with no Patch window open: the operator keeps the copy by typing ChangeDestination Root at the console (no way to discard it without the Patch menu is known). Needs bridge 0.19.0; a session in a stage with a Name needs bridge 0.45.0. verify reads each edited fixture back (address and/or name). A clean success lists per edit {fid, address?: [before, after], name?: [before, after]} in items (detail: true for the full rows).

Delete fixtures by FID from the patch, removing them from the show (with everything that refers to them, e.g. their values in cues and groups: the console handles references). Fixtures with sub-fixtures are refused. Pre-check (nothing sent on failure): every FID exists and has no sub-fixtures. Runs one patch session through the patch edit copy, never a dialog: read-only pre-checks (command line at Root, the copy closed, so nobody is in the Patch menu, no modal open, plus the tool's own checks), then enter the copy, apply the change there, an isolation check, commit, and read back. Requires exclusive: true. Patch changes need exclusive use of the console: the isolation check compares fingerprints of the copy and the live patch, left out the touched FIDs, over several seconds. It is best-effort detection of someone else's changes, not a guarantee, and on a mismatch nothing is committed and the copy is left open for the operator. A committed patch change has NO UNDO (Oops does not revert it). Takes about 10 s (mostly the isolation check). When a session cannot be finished, the copy is closed again only if it provably holds no change; otherwise the result says copyLeftOpen: true and the command line stays inside the edit patch with no Patch window open: the operator keeps the copy by typing ChangeDestination Root at the console (no way to discard it without the Patch menu is known). Needs bridge 0.19.0; a session in a stage with a Name needs bridge 0.45.0. verify reads the FIDs back and checks they are gone.

Read-only. Searches the fixture types the console can import: its grandMA3 library (a few fixtures plus scenery), its grandMA2 library (about 11 500 fixtures, the main one), the user library and WorldServer downloads (.xml and .gdtf). Every word of query must occur in the manufacturer, model or file name (case-insensitive), e.g. "chauvet festoon" or "mega hex". Each entry has the source, the file name to pass to gma3_patch_import, manufacturer and model, the mode names when the file is readable (grandMA3 and user .xml; grandMA2 .pxml files are encrypted, so their modes are known only after the import: gma3_patch_types then lists them), verified (false for user-library .xml and WorldServer files, whose import is not verified on the console yet; user-library .gdtf is verified) and inShow: show types already matching it by manufacturer and name (importing again would add a duplicate). Scenery (set@ files) is left out unless include_sets. Paginated (limit default 50, max 500; nextOffset is where the next page starts). compact: true lists file names only, per library, with inShow and notVerified (also per library) for the files that have them (default limit 500): use it for a broad query (a manufacturer) and ask for the full entries of the files you need. Every page is cut to about 40000 characters so it fits the client; the result says truncated when it was. gma3_patch_library_add puts a .gdtf or .xml file into the user library. Needs bridge 0.26.0.

Import one fixture type from the console's library into the show, so gma3_patch_add can patch it. file is a file name exactly as gma3_patch_library lists it. Pre-checks (nothing sent on failure): the file is in exactly one library, and the show has no type with the same manufacturer and name (the console would silently add a second one) unless allow_duplicate. Runs one patch session at the copy's fixture-type pool: Import /File "" /Path "" (no dialog; it reads the file from its folder, where Import Library looked the name up in a cached listing that could lack the user library), then waits for exactly one new type and claims it only when its name or manufacturer matches the file. The isolation check compares everything the live patch already has; the new type and the attributes it brings are appended and left out. Then commit and read back: the result has the new type's number, name, GUID and DMX modes with footprints, and attributesAdded. Imports of user-library .xml and WorldServer files are not verified on the console yet (the result warns); user-library .gdtf is (bridge 0.38.0). Requires exclusive: true (see gma3_patch_add for what the patch session means). A committed import has NO UNDO; gma3_patch_remove_type removes an unused type again, but the attributes it brought stay. Needs bridge 0.26.0.

Delete a fixture type no fixture uses, e.g. one imported by mistake. Pre-check (nothing sent on failure): the type exists and no fixture uses it. Runs one patch session; the type is deleted by its number, checked against its GUID. A type counts as used only by the fixtures whose type is that object (bridge 0.43.0; an older bridge also counts fixtures on another import of the same GDTF, which shares the GUID). Every type after it moves down one number (fixtures keep their type; only the number changes), and the result lists the renumbered types. The attributes the type brought into the show stay, unused: the console keeps them and they cannot be told apart from its own unused attributes. Requires exclusive: true. NO UNDO. Needs bridge 0.26.0.

Put a fixture-type file (GDTF .gdtf, or a grandMA3 fixture-type .xml) into the console's user fixture library, so gma3_patch_import can import it. The bytes go over the bridge: the client need not be on the console's machine. Give the file as content_base64 (its bytes, base64) with file_name, or as path (a file on the MCP server's host; file_name defaults to its name). file_name must be manufacturer@model[@revision].gdtf or .xml, the extension in lower case. Pre-checks (nothing written on failure): the name; at most 8 MiB; a .gdtf is a zip whose description.xml has a FixtureType (its name, manufacturer and DMX modes are reported); an .xml has a FixtureType element; the name is not in the user library yet unless replace: true, and in no other library (Import Library could not tell them apart). The file is written next to its target and moved into place only when its size and CRC-32 match. Read-back: the file's size and CRC-32 on the console, and gma3_patch_library lists it under source user. The show is not changed. Needs bridge 0.38.0.

Moves fixtures into a grouping fixture's children (parent: its FID), e.g. the rig under the MA Show Start's grouping fixtures FID 1-8, or back to the stage's top level (parent: "root"). FIDs, addresses, names, groups and presets are kept. The console asks how to keep the 3D placement: position "absolute" (default) keeps each fixture's place and rotation in the world; "relative" keeps its offset from the parent (the fixture moves with the parent's position and rotation). With a parent at the origin and unrotated both are the same. Pre-checks (nothing sent on failure): every FID exists, holds no fixtures itself, all share one parent (the top level or one top-level grouping fixture) in one stage, and the target is another top-level grouping fixture of that stage (type Grouping) or the top level. Move fixtures with different parents in one call each. In the copy: Cut, ChangeDestination, Paste, and the console's "Move Fixtures" dialog answered by the bridge, each step checked before the next (a failure cancels the dialog). The isolation check compares fixtures without their list positions, because a move renumbers the fixtures after the moved ones. Runs one patch session through the patch edit copy, never a dialog: read-only pre-checks (command line at Root, the copy closed, so nobody is in the Patch menu, no modal open, plus the tool's own checks), then enter the copy, apply the change there, an isolation check, commit, and read back. Requires exclusive: true. Patch changes need exclusive use of the console: the isolation check compares fingerprints of the copy and the live patch, left out the touched FIDs, over several seconds. It is best-effort detection of someone else's changes, not a guarantee, and on a mismatch nothing is committed and the copy is left open for the operator. A committed patch change has NO UNDO (Oops does not revert it). Takes about 10 s (mostly the isolation check). When a session cannot be finished, the copy is closed again only if it provably holds no change; otherwise the result says copyLeftOpen: true and the command line stays inside the edit patch with no Patch window open: the operator keeps the copy by typing ChangeDestination Root at the console (no way to discard it without the Patch menu is known). Needs bridge 0.19.0; a session in a stage with a Name needs bridge 0.45.0. verify compares each fixture with its state before the session: parent, address, name, its groups, and its 3D pose (absolute: in the world; relative: to the parent). A clean success lists each fixture as {fid, parent: [before, after]} in items (detail: true for the poses, groups and rows). Needs bridge 0.42.0.

Moves fixtures to another fixture type in the show whose DMX mode of the same name has the same channels and footprint (refused otherwise), keeping FIDs, addresses, cells, groups and preset values. Use it after importing a fixed revision of a GDTF or library type: the fixtures move from the old import to the new one, then gma3_patch_remove_type removes the old type. Also moves fixtures between a type and its layout copy (the same as gma3_assign_cell_layout). Runs one patch session (isolation-checked, committed with NO UNDO); requires exclusive: true. The read-back checks each fixture's type; a clean success lists each fixture as {fid, type: [before, after]} in items (detail: true for the rows). Needs bridge 0.29.0.

Stages (areas of the venue, e.g. "Main Floor", "Basement"; gma3_patch_add takes one by name). action "list" (read-only, the live patch): each stage's index (its position), number, name and nameKind ("default": an empty Name or one set to "Stage ", which read alike; "explicit": any other), fixtures (all, sub-fixtures included) and topLevel, whether it has a Spaces list and how many spaces. "create" {name} or {names: [...]}: appends stages (Acquire, then Name; the bridge deletes what it appended on any problem). "rename" {stage, name}. "remove" {stage}: only an empty stage (no fixtures, no spaces) and never the first or the only one; stages after it move up a place, and one with a default name then reads its new number (refused when that is another stage's name; an unreadable Fixtures, Spaces or children list is a refusal too). stage: the index or the name. Names: no characters the console strips (" . , and the like), trimmed, unique among the stages ignoring case (a stage may change the case of its own name). Pre-checks (nothing sent on failure) read the live stages. Runs one patch session through the patch edit copy, never a dialog: read-only pre-checks (command line at Root, the copy closed, so nobody is in the Patch menu, no modal open, plus the tool's own checks), then enter the copy, apply the change there, an isolation check, commit, and read back. Requires exclusive: true. Patch changes need exclusive use of the console: the isolation check compares fingerprints of the copy and the live patch, left out the touched FIDs, over several seconds. It is best-effort detection of someone else's changes, not a guarantee, and on a mismatch nothing is committed and the copy is left open for the operator. A committed patch change has NO UNDO (Oops does not revert it). Takes about 10 s (mostly the isolation check). When a session cannot be finished, the copy is closed again only if it provably holds no change; otherwise the result says copyLeftOpen: true and the command line stays inside the edit patch with no Patch window open: the operator keeps the copy by typing ChangeDestination Root at the console (no way to discard it without the Patch menu is known). Needs bridge 0.19.0; a session in a stage with a Name needs bridge 0.45.0. The isolation check leaves out only the stages the change touches (appended or removed ones, and the Name and number of a renamed stage and of those moving up). verify reads the stages back from the live patch: names in order, no two alike, and every stage's fixture count (an unreadable count makes it unavailable, not matched). Removing uses Delete on Stages, not verified on a console yet. Needs bridge 0.48.0; the bridge's own re-check of a removal (unreadable lists, a name clash) needs bridge 0.49.0.

For a dialog no structured tool answers, e.g. a macro's Lua Confirm() (gma3_run_macro reports an open dialog). action read (read-only): the top modal's class, title, message and buttons (text, enabled), or open: false. action press: clicks one button, named by its exact text, after checking that the open dialog still shows expect_title and/or expect_text as read returned them ("" for a dialog without a title) and that the button is there and enabled; a different dialog is never answered. Then the dialog is read again: closed, replaced by another dialog, or still open, with the console's last command (which does not name the button: check the effect on the object). Requires exclusive: true for press. What a button does has NO UNDO. Buttons that delete, overwrite, load a show or discard changes are pressed only because the call names them: read the message first. Tools that open their own dialogs (gma3_save_show, gma3_patch_move) answer them themselves. Needs bridge 0.42.0.

Load an existing Configuration onto an explicit page/executor, or plan and recast its functions on every referencing executor. Uses Assign Configuration At Page . or Recast Configuration . Load checks full page occupancy against the configuration size first. Recast defaults to a read-only plan: it scans all data pools (maximum64), pages(maximum200 per pool), and requires apply:true with executors exactly matching the fresh affected list, each {data_pool,page,executor}. Recast preserves existing executor sizes. Missing/unreadable targets and page/executor locks are refused; unlock explicitly first. preview:true sends nothing. Does not change selection, programmer, fader levels or trigger playback; stored custom commands are not executed. Read-back verifies configuration identity, unchanged assigned object and expected dimensions; returned functions are observations, not verification of the complete saved profile (that profile is unavailable). Saving profiles is unsupported because Store Page At Configuration returned OK without storing one. Mutations are serialised within this server; other operators/clients can change references after the plan. An uncertain command is never retried.

Read-only. For Page .: the assigned object; the executor's key, MA-key, fader and encoder functions, Fix and Lock; the page lock; for a sequence executor also the allowed function choices, the sequence's playback settings (wrap_around, priority, restart_mode, release_first_cue, auto_start/stop, master_go_mode, protect flags, ...), its Lock, whether it has active playback, which object owns each protection setting, and every executor in the current data pool that references the same sequence (sequence settings apply to all of them). The sequence is read by the address the executor reports, so a sequence from another data pool is reported as such (dataPool: other, ref: null). A value that could not be read is null and listed in unreadable. Sends no command and changes nothing.

Set key, MA-key, fader, encoder and MA-encoder functions, custom command triplets, Width/Height and Fix of the Sequence or Macro executor at Page . by writing its properties. Unlike 'Assign At', this never clears an unrelated unpress function. Functions are validated against the assigned class before writes; Macro faders/encoders allow only Empty. Sequence Flash, Temp, Swap, Black and Time are key-only. Custom command text is stored, never executed; command requires explicit enabled because the console auto-enables text. The flag is written after the text, even when initially unchanged. Commands preserve exact case and internal spaces; edge whitespace is refused because object reads trim it. Encoder continuous functions and left/right actions or enabled custom commands are mutually exclusive: conflicting requests fail before reads, and implicit mode clears are reported and verified. Storing disabled encoder text against an active continuous mode is refused unless that mode is explicitly cleared. Size changes check complete page occupancy, expanded footprints and proxies; collisions, unreadable or failed enumeration and expansion beyond page bounds are refused before any write. Shrinks precede growth. Executor settings belong to this executor only; sequence settings (Wrap Around, priority, ...) are configured with gma3_configure_sequence. lock: true/false sets the executor's own Lock. A page lock also blocks executor changes. Never sends Go, On, Off, Toggle, Flash or any other playback keyword and does not touch the selection, the programmer or fader levels; playback state is read before and after (playback.activeBefore/activeAfter) and configuration alone does not start playback. A locked target is refused before anything is sent (the console silently ignores writes to it) unless unlock: true, which unlocks the owning object, applies the changes and locks it again (relocking is attempted even after a failed change). preview: true performs only the reads and returns the planned changes (from -> to); values already set are reported as unchanged and never sent. Each value is written with one 'set' request whose reply must read back the requested value, because the console silently keeps the previous value for anything it does not accept; the first failure stops the remaining changes. A value that could not be read is unknown, never a default: the call is refused when a value the plan depends on (requested property, Lock, page Lock) is missing, and a set reply without a value is an unknown step. verify (default true) reads every changed property and the lock back. Mutations from this server are serialised, but not isolated from other operators or clients.

Set a sequence's playback settings by writing its properties: wrap_around (a chase loops only with Wrap Around on and a trigger on its first cue), priority, restart_mode, release_first_cue, auto_start, auto_stop, master_go_mode, auto_fix, auto_stomp, tracking, soft_ltp, off_when_overridden, kill_protect, swap_protect (protection from the Kill/Swap playback actions, not from editing), use_executor_time, include_link_last_go, xfade_mode, xfade_reload. lock: true/false sets the sequence's own Lock. Tempo links (SB-06): rate_master (a speed master 1-16 or "none": the cue timing (fades, delays, trigger times) runs at its effective BPM / 60, so 60 BPM is 1:1), speed_master (the phasers in the cues follow it), rate_scale and speed_scale (One, Mul2..Mul256, Div2..Div256), speed_from_rate. Masters are linked by name; a master without a unique name is refused. While a rate master is linked, moving the sequence's rate fader moves the shared master. Settings belong to the sequence, so they apply to EVERY executor that references it: the tool scans all pages and lists them (references) and warns when other executors share the sequence. Cue triggers and timing are set with gma3_set_cue_trigger / gma3_set_cue_timing. Never sends Go, On, Off, Toggle, Flash or any other playback keyword and does not touch the selection, the programmer or fader levels; playback state is read before and after (playback.activeBefore/activeAfter) and configuration alone does not start playback. A locked target is refused before anything is sent (the console silently ignores writes to it) unless unlock: true, which unlocks the owning object, applies the changes and locks it again (relocking is attempted even after a failed change). preview: true performs only the reads and returns the planned changes (from -> to); values already set are reported as unchanged and never sent. Each value is written with one 'set' request whose reply must read back the requested value, because the console silently keeps the previous value for anything it does not accept; the first failure stops the remaining changes. A value that could not be read is unknown, never a default: the call is refused when a value the plan depends on (requested property, Lock, page Lock) is missing, and a set reply without a value is an unknown step. verify (default true) reads every changed property and the lock back. Mutations from this server are serialised, but not isolated from other operators or clients. Batch form (sequences): the same settings on a list of sequences and ranges ("1 Thru 17"), each configured, checked and read back on its own; the result has one line per sequence (detail: true for every step).

Read-only. With group: the stored fixtures of Group (in the console's stored order, which is patch order) with their selection-grid X/Y/Z cells, PreserveGridPositions, lock, shared cells, bounds and gap count, read from the group's stored data (nothing is selected). Without group: the current selection in the order it was selected, with its grid cells (MAtricks-transformed when MAtricks is active). Distributions follow the cells, not the list order. Fixture ids are FIDs or dotted cell ids ("501.1"). Grid cells are the selection grid MAtricks and phasers use, not physical stage positions. Needs bridge 0.21.0.

Create or overwrite Group from a fixture list with explicit selection-grid cells. The cells are the order: the console stores a group in patch order and MAtricks, phasers and At a Thru b distribute along the grid, not along the list. Give either items ([{fixture, x, y, z}]) or an arrangement helper that expands into such a list: row (along one axis), rectangle (row by row, optional serpentine), mirror (left and right halves listed outside-in, right[i] mirrors left[i], optional centre gap), rows (one row per list, each spread over width cells). preview: true returns the expanded list, bounds, gaps and shared cells without sending anything. Rules: duplicate fixtures are refused (the console silently ignores a second selection); shared cells are refused unless allow_shared_cells: true; gaps and offsets are kept (preserve_grid_positions, default true; false lets a recall at the origin compact them); a fixture and its own cells (501, 501.1) are separate items; missing fixtures are refused. An existing group needs overwrite: true (its name is kept unless name is given); a locked group is refused. A name another group already has is refused before anything is sent, naming the holder (the pool's names are read once per call, compared case-insensitively; a duplicate makes lookups by name ambiguous, and whether the console would store "#2" is not verified for groups); on_name_taken: refuse (default) | allow_suffix (store anyway; a "#" read-back is a warning, not a mismatch). In the batch form a name an earlier group of the call was stored under counts as taken. Requires exclusive: true (not for preview): the tool clears the console's fixture selection (programmer values are kept), selects each fixture after its own 'Grid x/y/z' command, checks that the selection is exactly the plan before 'Store Group', sets PreserveGridPositions and the name, then (verify, default true) reads the stored group back and recalls it at Grid 0/0/0 to check order and cells (a one-fixture group is recalled at the cursor, so its recall checks the fixture and the read-back its cell), and finally clears the selection and returns the cursor to 0/0/0. Grid cells are not physical stage positions. Needs bridge 0.21.0. rows: rows of different lengths spread over one width (align spread, start or center); ranges run in their own direction ("402.36 Thru 402.1"). Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Read-only. The per-axis settings of MAtricks : wings, blocks, groups, width, shift, shuffle, and the fade/delay (seconds), phase (degrees) and speed (BPM) distributions as {from, to}; null means None. Also lists other settings that differ from a fresh MAtricks. Sends no command.

Set MAtricks per axis (x, y, z): wings, blocks, groups, width, shift, shuffle (null or 0 = None) and fade/delay (seconds), phase (degrees), speed (BPM) distributions as {from, to}. With wings, a distribution runs from the outer edges (from) to the centre (to), so a centre-out delay is wings 2 with delay {from: , to: 0}. create: true creates a missing object with 'Store MAtricks ' and then writes EVERY property (Store copies the programmer's selection MAtricks), so the new object holds exactly the request; reset_unspecified: true does the same for an existing one. Otherwise only the given settings change; values already set are not sent. Each value is one 'set' whose reply must read back the requested value (the console silently ignores values it does not accept); the first failure stops the rest. A locked MAtricks is refused, and so is a name another MAtricks has, before anything is sent, naming the holder (a duplicate makes lookups by name ambiguous; whether the console would store "#2" is not verified for MAtricks): on_name_taken refuse (default) | allow_suffix. Does not touch the selection or the programmer; apply it with 'Recall MAtricks '. preview: true reports the planned changes.

Read-only. preset: "." returns what the preset actually stores: per fixture and attribute the mode the value was stored in (selective; global, held by the lowest FID of a fixture type; universal, one holder), value (percent) or steps (each with absolute/relative, width, trans, accel, decel and the preset it integrates; absent layers are the console defaults width/trans 100, accel/decel 0), the phaser layers speedBpm, phase (degrees), measure (beats) and speedMaster (absent: 60 BPM, phase 0), fade/delay, and the source preset of an embedded value; plus PresetMode, StoredData, lock, how many objects reference it, and its dependencies (embedded sources) followed recursively with validity (a deleted source is an invalid dependency) and whether that inspection was complete. pool: returns the pool's default mode and input filter and the operator's store preferences (the defaults a store would otherwise use). Needs bridge 0.22.0.

Store the current programmer content into Preset .. Prepare the programmer first (gma3_select, gma3_set_attribute/color/position, At Preset ... for embedding); this tool only stores. Explicit rules: mode selective | global | universal (never the pool default: a default store resolves a mode conflict silently and can keep one fixture's values), or force global | universal for a forced conversion of an existing preset (removes its selective, or selective and global, data; needs existing: "merge"). existing: refuse (default) | merge | overwrite. fixtures: the scope; every active programmer value must belong to these fixtures (a fixture includes its cells) and each must have one; attributes (optional): exact attribute filter (an activation group, e.g. all ColorRGB_*, is activated as a whole); layers (default [absolute]; also relative, fade, delay, phaser) must cover every value's layers. Anything else in the programmer is refused, because the console stores every active value regardless of the selection. Also refused: universal mode with values that differ between fixtures, embed without a preset reference in the programmer, attributes a feature-group pool's input filter would drop (store into an All pool 21-25 or pass input_filter: false), a locked preset, and a name another preset of the same pool already has (the console keeps names unique within a pool and would store it as "#2"; the pool's names are read once per pool and call, compared case-insensitively, the holder is named, and storing a preset again under its own name is no collision): on_name_taken: refuse (default) | allow_suffix (store anyway; a "#" read-back is expected, with a warning, not a mismatch). embed (default false) stores references to the presets active in the programmer; matricks (default false) the selection MAtricks; keep_activation (default false); input_filter overrides the operator default for this store only. The command always carries /Programmer /Active, the mode, /Merge or /Overwrite, /Embed, /MAtricks, /KeepActivation and /NoConfirmation, so the operator's store preferences decide nothing and are not changed (read before and after); Look cannot be overridden per store, so the tool refuses while the operator's StoreLook preference is on. Requires exclusive: true (not for preview). verify (default true) reads the stored rows back and checks each programmer value by mode, value, layers and reference, unexpected content, the preset's mode, dependencies (recursively; incomplete inspection is reported) and that the store preferences are unchanged. Needs bridge 0.22.0. Batch form (presets): each preset from explicit content instead of the programmer: fixtures (ids or ranges: the target and the scope) with presets, intensity and/or values, or looks. They are built one by one in the console's Preview environment (its own programmer; the operator's Normal programmer and the output are not touched, checked before and after): from an empty Preview programmer, each look is checked right after its commands, then this tool's store, checks and read-back run there. A preset that fails does not stop the others; a name refused as taken fails only its preset, and a name an earlier preset of the call was stored under counts as taken. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Build a repeatable effect from structured steps and store it into Preset ., reading every step back. Steps: per attribute an absolute and/or relative value (unit percent, or physical: degrees for Pan/Tilt) or a preset called into the step, plus step timing (width, transition, accel, decel). phaser: fixture distribution (phase {from, to} in degrees over the selection grid, from > to runs the other way; {from, step}: a phase step per fixture, e.g. step 180 between neighbours; "spread": 0 -> 360 x (n-1)/n; {from: 0, to: 360} is one even cycle (360/n apart, like "spread": the console leaves the end out so the last fixture does not repeat the first), any other range uses both ends (0 -> 270 on 4: 0, 90, 180, 270; other whole cycles such as 0 -> 720 or 360 -> 0 are not established and the check accepts either); repeat {groups|wings|blocks: n} repeats it along X; shuffle: an XShuffle seed that permutes the phases) and playback speed (speed_bpm; measure = the number of beats one phaser cycle lasts at that speed, so the step widths, in percent of a beat, should add up to measure x 100; speed_master 1-16). These three are kept apart in the plan and the result. mirror {attributes, wings (default 2)}: the fixtures (grid order) are cut into wings and every second wing gets those attributes inverted (relative and physical values negated, percent 100 - v), e.g. the second beam's Pan. variants [sync, follow, mirror] build the versions of one effect into consecutive presets from preset, named " sync|follow|mirror": sync without a phase spread, follow with the phase (default spread), mirror with the spread mirrored about the centre (wings 2) and Pan (or mirror.attributes) inverted on the second half. Templates (instead of steps): dimmer_chase {on, off, speed_bpm, spread}, alternating_colors {colors: [{red, green, blue} or {preset}], x2, speed_bpm, snap}, pan_tilt {pan, tilt (degrees), speed_bpm, spread}: a relative circle around the current position. Position shapes in physical degrees around center {pan, tilt}: circle and figure8 (size = radius), cone (tilt held at tilt, pan sweeping a full turn and back), fan (closed on the centre, then open over size degrees of pan from the first fixture to the last), bounce (tilt up and down by size); default 20 BPM. Dimmer patterns for rows of fixtures or cells (grid order): runner (one on at a time), comet {tail: cells}, alternate, thirds, fill (fill up, then empty), sparkle {every, seed}; default 120 BPM. preview: true returns the expanded steps and the console commands. fixtures are selected in list order on grid X (or group: a stored group with its grid); up to 1024. Every attribute is checked against every fixture before anything is sent (the console ignores unsupported attributes silently). effects: several effects (each with its own preset, fixtures or group, steps or template, phaser, mirror, variants, name) built in one Preview session, one result line per preset with a compact phase summary (detail: true for every step); a failed effect does not stop the others. The effect is built in the console's Preview environment (its own empty programmer; nothing is output) and the operator's Normal programmer is fingerprinted before and after: it is never touched. The built programmer is checked per fixture, step and layer, including the phase per fixture, then stored with the gma3_store_preset rules (mode selective or global, existing refuse|merge|overwrite, step presets embedded, on_name_taken refuse|allow_suffix: a name, variant names included, that another preset of the pool has, or that two presets of the call share, is refused before anything is sent, naming the holder; the console would store it as "#2") and verified step by step; the Preview programmer is cleared and Preview left in every case. audition_ms (default 0: no playback) calls the stored preset on the fixtures in the Normal programmer, which must be empty, for that long and releases it with ClearAll. Requires exclusive: true (not for preview). If a build is interrupted, gma3_phaser_release leaves Preview. Needs bridge 0.23.0.

The stop/release path for gma3_build_phaser: when the console is in the Preview environment (an interrupted build), clears the Preview programmer and leaves Preview. clear_normal: true (with exclusive: true) also clears the Normal programmer (ClearAll), which stops an effect called there. Reports the environment and what is left.

Read-only. target: {preset: "N.M"} or {sequence, cue, part?} (part 0 by default). Returns every recipe line (standard and phaser) with its selection (group and its members), values (preset), MAtricks, filter, Enabled, SelectionMode, the console's last cooking state, and problems (missing or empty group, missing preset, disabled), plus the target's coverage: per fixture which attributes are cooked (from recipes) and which are stored directly. Lines whose coverage is not predicted (phaser recipes, filters) are flagged; presets that embed others are noted. Needs bridge 0.24.0.

Edit one standard recipe line of a preset or cue part (the target must exist). action add {selection: group, values: "N.M" preset, matricks?, name?, enabled?, selection_mode?} appends a line; set {line, ...fields} changes it (values: null clears the values); move {line, to} reorders; remove {line} deletes it. References are checked first; the result reads every line back (the edited one and that the others are unchanged or moved as asked). The console re-cooks an edited line by itself (MergeLowPriority) and a removed line's output disappears: the result shows the target's coverage before and after (autoCooked). The console also re-cooks a group or preset change by itself a moment later (in the background); gma3_cook_recipes cooks at once, verifies, and offers Merge, Overwrite and Remove. enabled: false switches a new line off before it gets values, so it never cooks. Phaser lines, filters and the per-line MAtricks columns are not edited by this tool (many cues at once, with the columns: gma3_store_recipe_cues). values is the plain string "4.2", never a number. preview: true returns the planned commands.

Write the standard recipe lines of up to 100 cue parts of one sequence in one call (at most 200 lines per part, 500 per call; a larger build is several calls). cues: [{cue, part? (default 0), name?, note?, lines: [{selection: group, values: "N.M" preset, matricks?, name?, enabled?, selection_mode?, x?/y?/z?: {wings, blocks, groups, width, shift, shuffle, select, fade/delay/phase/speed: {from, to}}}]}]. mode is required: replace deletes every line of the part first (refused while the part holds phaser lines), append adds after the existing ones. The cues must exist (gma3_store_cues creates them); name is the cue's name (Part 0), note its Note. Once for the whole call, before anything is sent: every cue part is read and every group, preset and MAtricks a line names must be in the show. Each line is written as gma3_edit_recipe adds one (Assign Group, Preset and MAtricks At the line, set for the other fields and the per-line MAtricks columns), and every reply is checked. Batch form: each cue part is an item: its steps stop at its first failure, the parts already written stay (nothing is undone or retried), an unknown outcome stops the rest, and its read-back is compact: the line count, then only mismatches (every field written, earlier lines unchanged on append, name, note). The console cooks each written line by itself (merge low priority). cook: a gma3_cook_recipes mode cooks every part afterwards, only when every part was written and matched (replace_uncooked and verify_cook as in gma3_cook_recipes). preview: true checks and returns the plan (detail: true every request). Phaser recipe lines are not written. Needs bridge 0.24.0.

Cook the recipes of a preset, a cue part, a cue (all its parts) or a whole sequence, at once and verified (the console also re-cooks group and preset changes by itself in the background a moment later, with merge low priority). mode is required: merge_low_priority (replaces cooked data, keeps every uncooked value), merge (also replaces uncooked values on the recipes' own fixtures and attributes), overwrite (deletes every uncooked value), remove (removes cooked data). First every affected target is listed with its lines, their problems (missing or empty group, missing preset), the coverage before and the cooked coverage the lines should give; merge and overwrite are refused while they would replace or delete uncooked values unless replace_uncooked: true. preview: true stops there. After Cook <target> /<Option> (verify, default true) each target is read back: every predicted fixture and attribute cooked, no cooked values on fixtures no line selects, uncooked values unchanged (merge_low_priority, remove) or changed only where allowed. Lines that are not predicted (phaser recipes, filters) are named; presets that embed other presets are noted (their recipes are not re-cooked). Needs bridge 0.24.0.

Read-only. The 16 speed masters (Master 3.N): name, fader, base BPM (from the fader: 50 = 60 BPM), speed scale, effective BPM (base x scale, what followers use), the console's own tempo text, learn mode, lock and problems (duplicate names make links ambiguous). usage (default true): per master the sequences that follow it by speed (phasers in their cues) and by rate (cue timing; the rate is effective BPM / 60 x RateScale) and the executors holding it. sound (default true): the onPC audio input device, the available devices, the SoundIn level and master 16 (the BPM master, driven by the input); beat detection and lock are not readable on 2.5.1, so synchronisation is never claimed. observe_seconds (0-10): samples the masters (master 16 when masters is not given) and reports how they moved. Distinct from timing masters (pool 5, fixed seconds) and cue timing.

Sets one speed master (1-16): the tempo as bpm, hz or seconds (one of them; it is the EFFECTIVE tempo under the final speed scale, 0 stops the master, at most 225 x the scale factor), speed_scale (One, Mul2..Mul256, Div2..Div256 or a power-of-two factor) and learn_mode (ignore_scale, respect_scale, auto_increase_scale: how taps treat the scale). Sends set LearnMode, set SpeedScale and Master 3.N At BPM x, in that order. Refuses a locked master. Every sequence linked to the master follows the change (named in warnings). Master 16 follows the sound input and may move again. Reads the fader and scale back (verify, default true); preview: true sends nothing.

action learn: Learn Master 3.N, one tap (the console times the taps itself; taps with interval_ms send several, with the network's jitter); double / half: DoubleSpeed / HalfSpeed (the speed scale one step up or down, the fader stays); reset: Speed1 (60 BPM, scale One). Refuses a locked master. Verifies the scale and tempo afterwards; a single tap cannot be verified (the console needs an interval).

OBSERVES OVER TIME on the server side (use it instead of a Lua waiting loop). Read-only. Samples the current cue of 1-8 running sequences for seconds (1-30, default 6) every interval_ms (default 40) and reports the observed step interval next to the configured one: the rate (rate master's effective BPM / 60 x RateScale, or the sequence's own rate fader) and, for chases whose cues are all Time-triggered with one trigger time, the predicted step interval. It starts nothing: run the sequences first. The phaser tempo (speed master) is reported as configured only; phaser output is not observable over the bridge.

Read-only. Without macro: the macro pool (number, name, line count; offset/limit, default 100). With macro: its name, note, lock, CLI, the line it is running now (null when idle) and every line exactly as stored (command, wait as seconds / "follow" / "go", enabled, add_to_cmdline, execute, name, note; a name of null is the default). check_references: true also lists the objects each line refers to (Sequence, Cue, Macro, Group, Preset, MAtricks, Page, Master, ...) and whether they exist.

mode (required): create (refuses an existing macro), replace (removes the existing lines first, keeping the macro, its appearance and its executor assignments) or append (adds after the existing lines). lines: [{command, wait (seconds, "follow" or "go" = a manual wait until the next Go+), enabled, add_to_cmdline, execute, name, note, raw}]; name, note, cli of the macro. Before anything is sent the references in each line are checked (single objects named with full keywords; a Store earlier in the macro counts as creating its object); raw: true stores a line unchecked. Refuses a locked or running macro, and a name another macro has (naming the holder; the pool's names are read once per call, compared case-insensitively; a duplicate makes lookups by name ambiguous, and whether the console would store "#2" is not verified for macros): on_name_taken refuse (default) | allow_suffix (store anyway); in the batch form a name an earlier macro of the call was stored under counts as taken. Sends Store Macro N, Delete/Store Macro N.L and one set per property; NEVER runs the macro. The console rewrites command text outside quotes (trims, collapses spaces, expands abbreviated keywords): every line is read back and compared exactly; a rewritten line is a mismatch unless accept_console_form: true (it is reported in rewritten either way). Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

action insert (line 1..count+1, needs command), set (any of command, wait, enabled, add_to_cmdline, execute, name, note), move (line -> to; sent as upward moves only, because a downward Move lands one place short), remove. References in a written command are checked unless raw: true. Refuses a locked or running macro. Every line is read back and compared with the expected order and content; accept_console_form as in gma3_store_macro. Never runs the macro. Batch form (edits): the edits run in order, each against the macro as the earlier edits left it (line numbers shift after an insert, move or remove); once an edit on a macro does not succeed, the later edits on that macro are not attempted. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

EXECUTES: action go sends Go+ Macro N (starts it, or continues it after a Go wait); off sends Off Macro N. Then OBSERVES the macro's running line over time, on the server side (no Lua loop needed), for observe_seconds (default 3, max 60): finished, paused_at_go (a manual wait), running, idle. After a go it also reads the console's top dialog: a line that opened one (a Lua Confirm(), e.g. the MA Show Start's wizards) waits for it, and execution.dialog then has its title, message and buttons, to answer with gma3_dialog (dialog: false when none is open; needs bridge 0.42.0; unknown on an older one). The result separates dispatched (the command was accepted) from observed (the run state seen); it never claims that every line succeeded, because a failing line does not stop a macro. Lines with a (prompt) ask the operator for input.

Read-only. Without timecode: the timecode pool. With timecode: name, playing, cursor and duration (seconds), the source (tc_slot internal / slot N, offset, auto start/stop), playback settings (loop mode and count, switch off, assert previous events), recording settings (the armed state is not readable; these tools never record), and every track group, track (its target) and event: time in seconds and as H:MM:SS.sss (or H:MM:SS:FF with fps 24/25/30/60), exact raw time, action (go, goto, off, flash_press, ...), cue. problems names tracks without a target, Goto events without a cue and unmodelled tokens. slots: true lists the 16 timecode slots (their time only: external reception is not readable). Needs bridge 0.25.0.

mode (required): create (refuses an existing show), replace (removes its track groups, keeps the show) or append (adds a track group). tracks: [{sequence, events: [{at, action, cue?}]}]: at is seconds, "H:MM:SS.sss", "H:MM:SS:FF" (with fps 24, 25, 30 or 60) or {frames, fps}, rounded to the console's 1/16777216 s; action is go (Go+), go_back, goto (needs cue), on, off, toggle, top, pause, kill, flash_press / flash_release, temp_press / temp_release (pairs are checked: allow_unpaired to override). Events are stored in time order; events at the same time keep the order given (the console runs them in storage order). settings: loop_mode (loop, pause, off), loop_count, tc_slot ("internal" or 1-16: configures the source only), switch_off (keep, off), assert_previous_events. Sequences and cues are checked before anything is sent; a playing or locked show is refused. Every event is read back and compared exactly. Never sends Go, Record or anything that plays. Needs bridge 0.25.0.

PLAYS when asked and OBSERVES OVER TIME on the server side (no Lua loop needed): play sends Go Timecode N (from the cursor, internal time; with a timecode slot the time comes from the slot), stop sends Off (playbacks it started keep running unless switch_off is off), rewind sends Top, seek writes the cursor (to: a time as in gma3_build_timecode). Recording is not offered. Then samples the cursor and the target sequences for observe_seconds (play: default 5) and, for play, checks every event the cursor crossed against the sequences' observed cue changes in order (goto -> that cue, go -> the next cue, off -> off, presses -> running; others are listed as not predictable). The result separates dispatched from observed.

Read-only. Position, rotation and mesh mirroring of fixtures in the 3D stage, with the axes' meaning: X positive is stage left, Y positive is upstage, Z positive is up. Rotations are degrees as the console reports them (it renormalizes them, e.g. 0/180/0 reads 180/0/180), plus the quaternion (x,y,z,w) that identifies the rotation exactly. Positions in the requested unit.

Set fixtures' position, rotation and mesh mirroring in the 3D stage (X positive stage left, Y positive upstage, Z positive up). Positions in unit (m, cm, mm, ft, in); rotations in degrees, always all three angles (the console renormalizes them, so one axis cannot be changed on its own; read the current rotation with gma3_fixture_positions). placements: [{fid, position?: {x?, y?, z?}, rotation?: {x, y, z}, mirror_mesh?}] (position axes not given stay). layouts expand into placements: line {kind: 'line', fids, from, to, rotation?} spaces fixtures evenly from..to (inclusive); arc {kind: 'arc', fids, center, radius, start_deg, end_deg, rotation?, follow?} spaces them on a horizontal arc (0° = stage left of the centre, 90° = upstage; follow adds the arc angle to rotation z); mirror {kind: 'mirror', pairs: [[source_fid, target_fid]]} puts each target at its source's final pose mirrored across the stage centre line (x negated, rotation y and z negated). preview: true returns the expanded plan with every fixture's current values and sends nothing. Refused while the patch copy is open (committing it would overwrite the positions). Scale is not offered: the console ignores scale writes. mirror_mesh is the fixture's MeshMirrorX flag (its 3D model mirrored). Read back a frame later: positions within 0.1 mm, rotations by quaternion. NO UNDO (Oops does not revert positions): the result's restore list holds every fixture's previous values in the same format. A clean success (all written, read-back matched or not requested) lists each fixture as {fid, position, rotation, mirror_mesh?} in items, the pose it now has, with the writes as one step; detail: true returns every write step and each fixture's pose before and read back.

Store several cues of one sequence in one call, each from explicit content: a look (fixtures with presets, intensity, attribute values and/or a phaser) or several looks, with an optional name, timing, trigger, command and note (the cue's Note, e.g. scene metadata a plugin reads) per cue; a cue with a command needs no look (stored empty). mode create refuses (nothing sent) when any of the cues exists; merge and overwrite store into existing cues. The store creates the sequence when it does not exist; sequence_name names it: a new name another sequence has is refused before anything is sent, naming the holder (a duplicate makes lookups by name ambiguous; whether the console would store "#2" is not verified for sequences), unless on_name_taken: "allow_suffix"; in the batch form a name an earlier sequence of the call took counts as taken. fade, delay, out_fade, out_delay, trigger and time given for the call are defaults for every cue (a cue's own keys win; a cue with its own trigger takes none of the call's time); each stored cue's TrigType and TrigTime are read back against what it was given. presets {pool, from, to} (instead of cues): one cue per existing preset of the range on fixtures, named after it, with the call's timing and trigger. replace: true deletes the existing cues first (the sequence object, its settings and executor assignments stay, checked). sequence_settings (as gma3_configure_sequence) are applied after the build in the same call; a priority above ltp lists the running sequences it would switch off (Off When Overridden on), and protect_running: true turns that off on them. Built in the console's Preview environment: its own programmer and selection, so nothing is output and the operator's Normal programmer is untouched (checked before and after). Each cue starts from an empty programmer (ClearAll, sent only in Preview), its looks are applied in order (presets, then intensity, then values; a later look wins on shared fixtures), each look is checked in the programmer (preset links, values per fixture and cell), then the cue is stored. A look that did not apply stops the batch before that cue is stored; the cues already stored stay (nothing is undone or retried) and the result lists every cue with its status. A cue's stored values cannot be read back on 2.5.1; the cue's existence, name, timing, trigger, command and note are. A cue stored without a name takes the preset's name. Requires exclusive: true. The result is compact by default: outcome, verification, one line per cue (look details only for a cue that did not match), the observed cycle as its cue order and step intervals, and only the steps that did not succeed (with a count of the rest); detail: true returns every step, every look and every sample. Batch form (sequences): several sequences, each {sequence, sequence_name, mode, fixtures, cues}, each built in its own Preview session with these checks. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Edit existing cues of a sequence in one call: the same trigger (TrigType/TrigTime), the same timing (Part 0 CueInFade, CueInDelay, CueOutFade, CueOutDelay, SnapDelay), one name per cue, and/or a command (command for all, commands one per cue). A switch from Time to another trigger sets each cue's TrigTime to 0 on the console, and a switch back keeps the 0: the result lists the wiped times (wipedTrigTimes); keep_times: true saves them in the sequence's Note first ([gma3-mcp trigtimes 1=2.5 ...]), and trigger time with restore_times: true sets them back and removes them from the note. Choose the cues with exactly one of cues (a list), from/to (a range, either end optional) or all: true; names are given in cue order, one per cue. Refuses (nothing sent) when the sequence or a listed cue does not exist, or the number of names differs. One Set() per property, cue by cue; stops at the first failure and reports every cue. Reads the written properties back per cue. Stored values and the programmer are not touched.

Build a chase into an empty or new sequence (or replace: true to rebuild one, keeping its executor assignments): one cue per step (steps: each a look or looks, a phaser in a look, an optional name and command; or presets: one cue per preset on fixtures, a list or a range {pool, from, to}), every cue Time-triggered after step_seconds (or cycle_seconds / number of steps) with an optional crossfade, and Wrap Around on, so the last cue is followed by the first. Built in the console's Preview environment: its own programmer and selection, so nothing is output and the operator's Normal programmer is untouched (checked before and after). Each cue starts from an empty programmer (ClearAll, sent only in Preview), its looks are applied in order (presets, then intensity, then values; a later look wins on shared fixtures), each look is checked in the programmer (preset links, values per fixture and cell), then the cue is stored. A look that did not apply stops the batch before that cue is stored; the cues already stored stay (nothing is undone or retried) and the result lists every cue with its status. A cue's stored values cannot be read back on 2.5.1; the cue's existence, name, timing, trigger, command and note are. A cue stored without a name takes the preset's name. Requires exclusive: true. sequence_settings and protect_running as in gma3_store_cues. Then, unless observe: false, PLAYS the chase (Goto cue 1, live output) and OBSERVES it over time on the server side (no Lua loop needed), sampling its current cue to verify one cycle: the cue order through the wrap and each step against step_seconds / the sequence's rate. A cycle longer than observe_max_seconds (default 45, at most 120; keep it under your client's request timeout) is observed from a late cue through the wrap instead. The chase is switched off afterwards unless leave_running: true. The result is compact by default: outcome, verification, one line per cue (look details only for a cue that did not match), the observed cycle as its cue order and step intervals, and only the steps that did not succeed (with a count of the rest); detail: true returns every step, every look and every sample.

Read-only. One fixture type of the show (number or name, as gma3_patch_types lists it). Per DMX mode: footprint, breaks, the root geometry and its size (the model's length, width, height), the cells (the geometry references a patched fixture's cells come from: name, position, break offset) and, with channels, every DMX channel expanded per cell: break, offset (1-based within the break), fine/ultra offsets, attribute(s), cell, virtual (no DMX address, e.g. an RGB fixture's dimmer). addressesUsed counts the footprint's addresses the channels cover; limitations say what could not be established. geometry: the tree as flat nodes (name, class, parent, depth, position, rotation, model, the template a reference points to); with a mode, only the geometry that mode uses. Without a mode, every mode is summarised (cells, footprint) and channels and geometry are left out unless asked for (a pixel fixture's full listing is large). Lengths in unit (m default; cm, mm, ft, in), angles in degrees. Needs bridge 0.28.0. cellOrder (SU-19): the cells' physical order along the string is their DMX order, which can differ from the cell numbers (the Festoon's 2-string mode: 1-9, 19-29, 10-18, 30-40); stepsInDmxOrder checks it against the type's positions. Use it with gma3_layout_cells order: "dmx" and group lists {cells_of: , order: "dmx"}. wheels (bridge 0.34.0): each wheel's slots with name, colour, media and the channel sets that select them (mode, channel, attribute, DMX range in the channel's resolution; null when the resolution is unknown); slotColors says set, unset (every slot white: ask, do not guess) or unreadable. No cell order is given from an incompletely readable address.

Positions the cells of a multi-cell fixture along a path. A cell has no position of its own: its place is in the fixture type, shared by every fixture whose DMX mode uses that layout. scope "shared" (default) writes the type's layout: every fixture using it moves, and affects must list exactly those FIDs (preview: true lists them). scope "own" first copies the type for own.fixtures (default: the fixture) under own.name, moves them to the copy in a patch session (FIDs, addresses, cells, groups and preset values are kept), then lays out the copy; the other fixtures keep theirs. path: shape line (direction), square_wave (legs of leg_length along leg_direction, stepping leg_step along advance between them), zigzag (diagonal legs, advancing leg_step per leg) or points; cells are placed every spacing along the path from origin; axes the path does not use keep each cell's value unless origin sets them. count places only the first cells; rest keep|last. Lengths in unit (m, cm, mm, ft, in), relative to the cells' parent geometry (the fixture's own position, rotation and mirroring then apply: place the fixture with gma3_place_fixtures). Refused while the patch copy is open. No undo: previous holds the positions before the call. Read back per cell. Needs bridge 0.29.0.

Moves fixtures to another fixture type that is a layout copy of theirs (as gma3_layout_cells scope own creates) or back to the original, so several fixtures share one layout. The target type must have a DMX mode of the same name with the same channels and footprint (refused otherwise). Runs one patch session (isolation-checked, committed with no undo); FIDs, addresses, cells, groups and preset values are kept. Requires exclusive: true. A clean success lists each fixture as {fid, type: [before, after]} in items. Needs bridge 0.29.0.

Read-only. Every universe in use (patched or set to output, plus any asked for): fixtures patched, whether it is granted, its grant request, ports, merge mode, and the Art-Net / sACN entries that cover it with the protocol universe they send it as. Each universe is explained: idle, not granted (no output and unreadable values, with why), granted but sent by no protocol, or sent as which universes. Also both protocols (output and input switches, interface, every data entry: local universes, amount, protocol universe, mode, enabled, priority) and the output stations. Use it when gma3_fixture_output or gma3_dmx return no values. Needs bridge 0.30.0.

Changes the console's DMX output configuration: protocol (artnet or sacn) output on or off; its data entries (entries: edit one by number, add: true for a new one, remove: true), each mapping local_universe .. +amount-1 to protocol universes from universe (Art-Net: absolute 0..32767 = net x 256 + subnet x 16 + universe; sACN: 1..63999), with mode, enabled and (sACN) priority 0..200; and grant_request (universes, value auto|on|off), which asks for a grant without creating one. Validated before anything is sent; the console silently ignores or clamps invalid values, so every written property is read back. preview: true shows the plan. A change that makes a protocol send DMX onto the network (output on with an enabled entry) needs network: true. Requires exclusive: true. No undo: previous holds the values before. Needs bridge 0.30.0.

Read-only. The values and types (integer, double, text) of global and user variables, by name, and every $variable the macros reference (referenced, default when no names are given: each with the macro lines that use it). Variables cannot be listed on grandMA3 2.5.1 (no API enumerates them), so a variable that no macro references is read by its name. With scope both (default), resolvesTo says which one a $reference uses: a user variable shadows a global one. User variables are the bridge's user's. $variables expand in commands sent through gma3_command (outside quotes). Needs bridge 0.31.0.

Set a global or user variable to a value with its type (integer, double or text, as SetGlobalVariable / SetUserVariable do; a text keeps quotes exactly), or delete it, then read it back (value and type). User variables are the bridge's user's (another user profile has its own). Macros and cue commands use them as $name (outside quotes); a user variable shadows a global one. Needs bridge 0.31.0. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

OBSERVES OVER TIME on the server side (use it instead of a Lua polling loop). Read-only. Samples the programmer values (source programmer, default) or the DMX output (source output) of fixtures for seconds (1-30, default 5) every interval_ms (50-2000, default 200) and reports which channels changed: first and last value, min/max and the timed changes. Programmer: fixtures is a range ("101 Thru 112") or a list. Output: 1-8 fixtures; output on a universe that is not granted cannot be read, and the tool says so up front (outputState) and samples nothing. attributes limits the channels (Dimmer, ColorRGB_R, ...). It starts nothing: run the playback or phaser first. A running phaser in the programmer reads as its steps (not a moving value); watch its output instead.

Read-only. The console's OSC input and output: EnableInput / EnableOutput, Interface and PreferredIP, every OSC line (port, prefix, Receive, Receive Command, Send, Send Command, destination IP), the network interfaces, and what it means: whether commands are accepted and from where (the console listens on every interface whatever Interface and PreferredIP say), where output goes, and whether this server's own OSC sender (gma3_command via osc, gma3_start_bridge) reaches a line. Needs bridge 0.33.0.

Switch OSC input / output, set the preferred IP, and add, edit or remove OSC lines (name, port, prefix, destination_ip, receive, receive_command, send, send_command, echo_input, echo_output, note). Lines are UDP. Validated first; every write is read back. A port change on a receiving line re-binds input (input off for about 0.4 s and on). network: true is required when the change opens a port that runs OSC commands while this machine has an address beyond loopback: the console listens on every interface, so anyone who can reach this machine can then run commands. It is also required for new output to an address outside loopback. Requires exclusive: true; preview: true shows the plan. No undo: previous holds the values before. Test with gma3_test_osc_input. Needs bridge 0.33.0.

Proves that the console receives OSC commands, with no shell: sends /[prefix/]cmd SetUserVariable "McpOscTest" "" to 127.0.0.1 on the port of each line with Receive Command (or line), then reads the variable back through the bridge. Matched when the console ran it. The variable is deleted afterwards; refused when it already exists or input is off. Needs bridge 0.33.0 (and 0.31.0's variable ops).

Read-only. The console's current show, the shows folder and every .show file in it (name, size, time as ISO and as the console's local wall-clock time), newest first, and a dialog when one is open. Use it before gma3_save_show to choose a name that does not replace another show. Needs bridge 0.35.0.

Save the show: under the current name (default) or a new name (which becomes the console's current show). A new name is at most 32 characters (the console cuts longer names; non-ASCII counts in UTF-8 bytes) and is refused before anything is sent. Refuses to replace another show's existing file unless overwrite: true, and refuses while a dialog is open. SaveShow is sent so that it cannot stall the bridge; the tool answers SaveShow's own confirmation ("Change show file name?", or "... and overwrite existing show file?" with overwrite: true) and nothing else. Verification: matched when the file carries a time from this save and the console names it current; the result reports the file (size, time). Requires exclusive: true. Use gma3_show_files to see the files first. Needs bridge 0.35.0.

Read-only. The show's tags (one show-wide pool): number, name, type (None / Kill Instant / Kill Delayed), Forward Commands, pool action, appearance, note, reference count, and the objects that carry each tag (class, name, data pool, address, protect), from the console's reverse lookup. Answers "which sequences are tagged Encore" in one call: tags: ["Encore"], class: "Sequence". Tags are paged (offset/limit, default 100) and so are each tag's objects (references_offset/references_limit, default 200), with totals and incomplete flags. With of: "" it reads the tags given objects carry instead (a cue's tags are on its Part 0). gma3_get_object, gma3_objects and gma3_list_children also return an object's TAGS as [{tag, name, protect}]. Needs bridge 0.36.0.

Create a tag (Store Tag n "name") or rename it (if_exists: "rename"), then read it back. An existing number is refused unless if_exists is rename (Store on an existing tag changes nothing). Names follow the rules of every object name: characters the console removes (a comma among them) are refused before anything is sent. Tags are show-wide. Delete with gma3_delete_tag. Needs bridge 0.36.0. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Delete a tag (by number or exact name; a name more than one tag has is refused). It leaves every object that carries it: removedFrom lists them (from the console's reverse lookup, before the delete) and each is re-read afterwards (stillCarries), and the slot is read back empty. Needs bridge 0.36.0. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Assign a tag to objects, or remove it (off: true), with Assign [Off] Tag n At , and read back every object's tags. The tag is given by number or exact name and must exist (the console answers OK to an unknown tag and changes nothing); a name is resolved to its number first, and a name more than one tag has is refused. target is a command-line reference with numbers: "Sequence 950 Thru 952", "Group 5", "Macro 3", "Macro 3.1" (a line), "Sequence 5 Cue 2" (the tag lands on the cue's Part 0 and is reported there), "Preset 4.1", "Tag 7". data_pool addresses the objects of another data pool. Fixtures cannot carry tags. protect sets the Protect flag of each reference: Kill Instant turns the other tagged sequences off when one starts; Kill Delayed does so after the started cue's in-fade; a reference with protect keeps running (live, onPC 2.5.1). Needs bridge 0.36.0. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Set a tag's type (None, Kill Instant, Kill Delayed), Forward Commands (whether Go+ Tag n / Off Tag n reach the tagged objects), pool action (Pool Default, None, Go+, Off, Toggle, Flash, Temp, Top, Pause, List Reference), appearance (a number, or null to clear) and note, then read each one back. Kill Instant turns the other tagged sequences off when one starts; Kill Delayed does so after the started cue's in-fade; a reference with protect keeps running (live, onPC 2.5.1). Set the type before the sequences run (the manual: otherwise it works once they have been started). Values outside these lists are refused before anything is sent. Needs bridge 0.36.0. Batch form: give the list instead of the single object's fields; the other arguments are defaults for every item (an item's own fields win). Each item gets the single form's checks and read-back, and its own outcome; items run in order, nothing is retried, an unknown outcome stops the rest, and the result has one line per item (detail: true for every step).

Read-only. Whether the tempo-sync plugin (bdstark/gma3-beat-sync, a separate console plugin that follows an external tempo source) is imported in this show and running, and what it publishes: state, tempo, beat, phase, peers, playing, drift, frame timing, the last action (ok / failed / uncertain), problems and errors; plus its configuration (master, quantum, actions, resync list, ...). Running means its State is not "not running" and its status was written within 2 s by the console clock (after a show load it is stopped and its saved values are stale). It says plainly when the plugin is not imported or not running and how to start it. Needs bridge 0.31.0 (0.35.0 for the clock).

Set or clear the tempo-sync plugin's configuration (bdstark/gma3-beat-sync; console global variables BeatSync.*, read by the plugin every 0.5 s and saved with the show), then read it back: master (speed master 1-16 the session tempo is written to), quantum (beats per bar 1-64), start_stop (on: beat actions only while the session plays), resync (sequences to ReSync on every bar; they must exist), on_bar / on_beat / on_start / on_stop / on_join / on_leave (console commands), actions ([{slot 1-16, every N beats, phase, command}] or {slot, clear: true}), tempo_threshold (BPM), lead_ms (0-200; ~17 puts the effect on the beat). null clears a key. Interfaces (multicast) is a network setting and is refused. Works whether or not the plugin runs; when it runs, the problems it reports after reading the change are included. Needs bridge 0.31.0.

Read-only: which numbers a show already uses, per pool, before you store into it. For each pool: stored (the number of stored objects), used (their numbers as ranges, "1-11, 5001-5534"), with names: true [no, name] pairs, and with free: {size, from?} the first free block of that size ("21-40"; null when there is none up to 9999 or the read is incomplete). Pools: DataPool pools by name ("Groups", "Sequences", "Macros", "MAtricks", "Timecodes", "Layouts", ...); a preset pool as "Preset 4" or in preset_pools (stored presets, not the pool's 1000 slots); "PresetPools" (every preset pool as [no, name, stored, used]); "Page 2" (its executors with an assigned object as [no, class, name]; covered: the numbers a wider executor (Width > 1) spans, never free; an assignment that cannot be read (an invalid handle, or a read that raised: bridge 0.47.0) is listed as unreadable and makes the page incomplete; free searches one row: 101-198, 201-298, 301-390, 401-490, from 101 by default); "Pages" (every page as [no, name, executors used, used]). Every pool is read to its end page by page; complete: false with reason (keeping what was read) when a read fails, the console cannot list the children, the pool changes during the read or an object has no number (an executor without a readable No); free blocks are offered only from complete reads and need bridge 0.47.0 (with an older bridge unconfirmed says why and free is null); the call is an error only when no pool could be read at all. Ranges such as "Page 1.101 Thru 1.115" are not accepted (executor ranges can hang onPC). Use this instead of gma3_objects "Macro Thru" or a Lua walk of the pools.