Fusion - the Fusion 360 Bridge

@@ -3,26 +3,931 @@ All notable changes to the Adom Bridge Fusion 360 bridge, newest first. Canonical: https://wiki.adom.inc/adom/fusion-bridge · GitHub backup: `adom-inc/fusion-bridge` -## Unreleased+## 1.13.28 (unreleased) -- `fusion_export_optimized_glb` now produces a publishable molecule, not just a GLB. It exports the EAGLE `.brd`-  (new `board` arg, default true) and sends it to service-step2glb as the `board` part, the same contract as-  `step2glb convert --board`. With the board the service generates the footprint and symbol JSON with per-pad-  wire-attach Z; without it `footprint_applied` was null and the GLB could not be published as a molecule.+From Aditya Angajala (PR #17): `fusion_export_optimized_glb` produces a publishable molecule, not just a GLB.+- It exports the EAGLE `.brd` (new `board` arg, default true) and sends it to service-step2glb as the `board` part,+  the same contract as `step2glb convert --board`. With the board the service generates the footprint and symbol+  JSON with per-pad wire-attach Z; without it `footprint_applied` was null and the GLB could not be published. - The export and `fusion_fetch_optimized_glb` download the job's side artifacts beside the GLB:   `<stem>_footprint.json`, `<stem>_symbol.json`, and `<stem>.web.glb` when the service made a web-grade twin.-  Replies carry `boardPath`, `footprintPath`, `symbolPath` and `webGlbPath`.-- Replies carry the molecule-publish gates as `gates` (pinSize, pinSizeSource, footprintApplied, footprintPins,-  footprintRebase, contactZ, warnings), and the `_hint` names any gate that is not met.-- New optional `compress` arg (quantize, draco or none) is passed through to the service.-- Every export also writes the fab files and an export record (board-look EXPORTERS.md, Decision 6 and-  Aditya 2026-10-08). `<stem>-fab.zip` is the Gerber + drill output of the bridge's own JLCPCB CAM job (new-  `gerbers` arg, default true). Fusion's CAM writes one Excellon file for plated and unplated holes, so it is-  marked mixed. `export.json` beside the outputs lists the tool and version (from the .gbrjob), the exporter-  version, every source file with its sha256 and role (the STEP, the .brd, the silk PNGs, the zip and each-  Gerber, drill and job file inside it) and the stackup the Gerber job knows (thickness, copper layers, size).-  Nothing is renamed in the STEP or the Gerbers, so the hashes describe the design. Replies carry `fabZipPath`-  and `exportRecordPath`.+  Replies carry `boardPath`, `footprintPath`, `symbolPath`, `webGlbPath` and the molecule-publish `gates`+  (pinSize, pinSizeSource, footprintApplied, footprintPins, footprintRebase, contactZ, warnings); the `_hint`+  names any gate that is not met.+- Every export also writes `<stem>-fab.zip`, the Gerber + drill output of the bridge's own JLCPCB CAM job (new+  `gerbers` arg, default true; Fusion's one Excellon file is marked mixed plating), and `export.json`: tool and+  version from the .gbrjob, exporter version, every source file with sha256 and role (STEP, .brd, silk PNGs, the+  zip and each file inside it) and the stackup the Gerber job knows. Nothing in the STEP or Gerbers is renamed.+  Replies carry `fabZipPath` and `exportRecordPath`. Merged onto master's silk cleanup (#113) and `compress` check.++## 1.13.27 (2026-10-30)++From Drew Owens (PR #28): the mechanical layer on big assemblies, profiled inside Fusion on a 4,579-occurrence+production assembly built from 23 referenced designs.++- The revision digest every guarded call pays went from 32.6 s to 5.2 s: entity tokens are read only on a miss,+  refused timeline-index reads are remembered per feature revision, and components come from the occurrences read.+- References: an occurrence registered this session reuses its token, and a reference resolves by walking its path's+  names (248 ms to 5.7 ms). Joint solving compares each occurrence with the one at its path instead of every pair.+- Write guards keep each body's witness by revision and reuse the pre-check's health walk.+- `bom` reads metadata and physical properties once per definition; `budgetSeconds` (default 40) stops the cloud+  part-number reads and marks the rest `nativePending` (cached for the next run). `inspect` leaves out body metrics+  above 200 components (`bodyMetrics:true`) and the health walk above 200 timeline items (`health:true`).+- `efficiency_report` returns the full target. The add-in is 1.0.28; the exe embeds the new `schema.json`.++From Drew Owens (PR #30): the hang gate never kills a Fusion that is using CPU. On 2026-10-30 it killed a Fusion 37+minutes into a long build script whose request had timed out, closing 24 (saved) documents. `confirmed_hung` now also+needs the Fusion family under 15% of one core over 1.5 s, and its 180 s clock restarts whenever Fusion works. Busy+replies carry `keptBy` (`under-ceiling`, `fusion-cpu-active`) so a caller sees what keeps Fusion alive.++From Drew Owens (PR #31): `mech_validation.json` regenerated from master after #28, with the 12 validation cases for+`inspect`'s `bodyMetrics`/`health` and `bom`/`bom_export`'s `budgetSeconds` (2,805 cases).++## 1.13.26 (2026-10-30)++- Engine 0.21.1 (standard 0.24.2): lint_library's duplicate_pad_number counts same-numbered pads that touch or overlap+  as one land, so a split exposed pad is no longer a false warning. Otherwise as 1.13.25, which this replaces before+  it was smoke-tested.++## 1.13.25 (2026-10-30)++- Engine 0.21.0 (standard 0.24.0). `fusion_lint_library` (the standard's lint_library): a .lbr read offline (pads,+  courtyard on tKeepout, silk on tPlace, 3D packages, descriptions; each component's pins, footprint and MPN) and judged+  by the shared engine, every problem a finding with a rule name and a severity.+- `fusion_update_footprints_from_library` (the standard's update_footprints_from_library, #27), the plan: each placed+  footprint against the same-named package in the .lbr files named, pad by pad (up_to_date, differs with the diff, or+  library_not_found). apply is refused with the plan: Fusion's UPDATE asks about each part in a dialog.+- `fusion_edit_footprint` writes a library that has footprints but no components yet (it checked it with the full+  preflight, which demands symbols, and refused). 349 verbs.++## 1.13.24 (2026-10-30)++- `fusion_list_installed_libraries` (the standard's list_installed_libraries): the libraries Fusion offers to place+  from are the hub's electronics libraries (.flbr, Library Manager's Hub Libraries tab). Fusion keeps no local list and+  draws that tab without UI Automation, so the verb walks the hub's projects and folders through the signed-in session+  (breadth first, to a depth, within a time budget).+- `fusion_add_symbol_art` (the standard's add_symbol_art): the chip outline adom-symbol baked into a KiCad symbol, drawn+  into the component's symbol fitted to its body (the TPS54202's 162 polylines live). Offline on a .lbr.+- uninstall_library, normalize_bodies and sch_sheet_symbol answer not_supported: taking a hub library out would delete+  the file for everyone; a Fusion footprint's 3D model is a cloud package placed when made, with no stored offsets; and+  a Fusion module cannot be made from a text command (checked live). 347 verbs.++## 1.13.23 (2026-10-30)++- The standard's app tier in Fusion's terms:+  - `fusion_diagnostics`: facts for a bug report without driving Fusion (bridge version and folders, bundled add-in,+    Fusion launcher, processes and windows, whether the add-in answers, the Adom/Fusion/Autodesk environment with the+    values of credential-named variables never shown);+  - `fusion_instances`: every running Fusion process;+  - `fusion_progress`: the long operation in flight, measured phase and verb timings, recent runs;+  - `fusion_foreground {reason}`: Fusion brought in front, the sanctioned exception: the user is notified why and given+    three seconds first.+- panel and selection answer not_supported: Fusion's editors show their own panels (the bridge opens surfaces with+  fusion_show_*), and Fusion does not show the user's board selection to the bridge (a ULP's ingroup() reads no part+  even right after a GROUP, checked live). 345 verbs.++## 1.13.22 (2026-10-30)++- `fusion_variants` (the standard's variants): a design's assembly variants, each with its not-fitted parts and+  alternate values, read from the schematic. Making, changing or removing one is refused with not_supported: Fusion+  2706 takes EAGLE's VARIANT from a text command (any form, schematic or board) and changes nothing.+- `fusion_silkscreen_prep` (the standard's silkscreen_prep, in Fusion's terms): designators on copper moved off it where+  they fit (the engine's silk_designators), counted before and after; loose silk outside the board listed. A footprint's+  own silk lines are its library package's and cannot be clipped on one board: the fab's CAM clips silk at mask openings.++From Drew Owens (PR #27): CAM from the typed mechanical layer, and exploded renders that work on big assemblies.++- `cam_job` makes a milling job in one journaled call:+  - a setup on the given bodies, and operations in order (`face`, `adaptive`, `contour`, `parallel`, `scallop`, `pocket_clearing`, `drill`);+  - tools from Fusion's sample library by type and nearest diameter, with optional parameter overrides by name;+  - drilling finds the bodies' holes of the drill's diameter unless `holeFaces` are given;+  - it generates the toolpaths, reports each operation's warnings and errors and the machining time, and with `post` writes G-code+    through a post from Fusion's library (FANUC, Grbl, HAAS, ...);+  - a failed job deletes its setup.++  `cam_tools` lists the library's tools, and `cam_inspect` reads a document's setups and NC programs. Live: a pocketed, drilled plate gave+  valid face, adaptive, contour and drill toolpaths and a 1,901-line FANUC program. Known gap: the FANUC O-number stays O1001.+- `exploded_view_render` captures only the moved occurrences and their parents (children follow), so a 4,579-occurrence assembly+  renders instead of hitting the 256-instance budget. It checks home poses within 0.01 mm (`restoredWithinMm`) instead of exact float+  equality, which flagged a clean revert on a big assembly as `restore_failed`.+- 67 typed operations; the add-in is 1.0.27, and the exe embeds the new `schema.json`. 341 verbs.++## 1.13.21 (2026-10-29)++- `fusion_replicate_layout` (the standard's replicate_layout): one channel's placement copied to matching channels round+  each target's anchor, turned by the anchors' rotation difference; bottom parts stay mirrored; one guarded move.+- `fusion_symbol_prims` and `fusion_set_visibility` (the standard's): a component's drawing counted (pins, lines,+  rectangles, polygons, body rectangle in mil, footprints), and a parameter shown on the sheet or hidden by adding or+  removing its >NAME text in the component's symbols. Offline on a .lbr.+- component_classes answers not_supported: an EAGLE board has net classes but no component classes or rooms. 339 verbs.++From Drew Owens (PR #26): exploded-view animations for operators, and photoreal renders.++- `exploded_view_render` plays the same steps as `exploded_view_plan` on the real occurrences and saves one viewport image per+  frame from a camera fitted to the most exploded state. Then it reverts every move and verifies each instance is home and the+  document's flags are unchanged. It refuses a design that already has an uncaptured move (the revert would discard it), and+  names any part that did not reach its planned pose (`heldBack`). The reply carries timed captions from the steps' titles and+  instructions, and the ffmpeg line that joins the frames into MP4 (Fusion's API has no video export). Journaled.+- `render_image` renders with Fusion's local renderer from a fitted standard view or the current one, at a size and quality,+  optionally transparent (PNG only) or with the ground. It waits for the render, then restores the camera and every render+  setting. Journaled. Fusion's API cannot choose the render environment or cancel a render; after `render_timeout` the render may+  still write the file.+- Edge cases checked live on Fusion 2705:+  - nested children in their parent's frame, a rotated part along its own axis, a rigidly jointed part and component-pattern copies;+  - someone's uncaptured move refused and left in place, overwrite, the frame budget, bad folders and sessions;+  - render settings and camera restored, JPEG output, and a real timeout.+- 64 typed operations; the add-in is 1.0.26, and the exe embeds the new `schema.json`.++## 1.13.20 (2026-10-29)++- Engine 0.20.0 (standard 0.23.0). `fusion_bodies` gives a part turned off the axes its rectangle along its own axes+  (`cx, cy, w, h, rotation`, measured by Fusion's oriented bounding box along the part's own x axis) beside the world box,+  so height_check, placement_check and the other body checks stop counting the box's empty corners. A SOT-23-5 at 45+  degrees: world box 4.07 x 4.07 mm, its own rectangle 2.8 x 2.9.+- `fusion_simulate`: `analysis {type: noise, source, output, reference?, sweep, points, start, stop}` answers the output+  and input noise spectra (`onoise`, `inoise`, V/rtHz) and their integrated `totals` (an RC: sqrt(4kTR) at 10 Hz,+  2.03e-7 V integrated against kT/C's 2.04e-7). `monteCarlo {runs, distribution, seed, tolerances}` draws every R, C and L+  with a plain value within its tolerance (uniform, or gaussian with sigma a third of it), a signal per run with the drawn+  values as its step; the same seed draws the same values.++## 1.13.19 (2026-10-29)++- review_board, board_report, pin_pad_check and schematic_review give the engine each part's attributes as+  `sheetParts[].params` ({name, value}, empty values left out), so vendor numbers and datasheets the parts carry count.+  On BQ25792 the 48 parts with an LCSC number now miss only Mouser and DigiKey, and the 5 with a DATASHEET have one.++## 1.13.18 (2026-10-29)++From Drew Owens (PR #25). Design efficiency: measure what makes a design slow, and stop the bridge from making it slow.++- `efficiency_report` reads what makes a design slow (timeline make-up and health, Position snapshots, Move features,+  size, repeated definitions made by Paste New, instance-weighted faces, imported history, wires in a parametric design,+  big sketches, pattern compute options, modeled threads, meshes, empty components) and returns findings with the fix.+  It never changes the model and is journaled like `bom_export`; a 4,579-occurrence cell took 76 s.+- `occurrence_update` keeps a move by editing the occurrence's initial position (Fusion's Edit Initial Position) when+  Fusion allows it, so nothing joins the timeline; an earlier occurrence is edited with the marker rolled back to it and+  restored. `method` chooses, and the reply's `placement` says which was used. Nine moves: 0 snapshots, against 9.+- Rectangular and circular patterns take features, faces or components (occurrences, patterned in their parent) as well+  as bodies, with `computeOption` (identical by default, optimized, adjust). The revision guard accepts a component+  pattern's copies. On a 100-hole plate a feature pattern recomputed in 0.24 s, the sketch of circles in 0.87 s, adjust+  in 2.42 s.+- The `fusion-design-efficiency` skill: the playbook, with those benchmarks and its sources.+- The add-in is 1.0.25 (new op `efficiency_report`: 62 typed operations); the exe embeds the new `schema.json`.++## 1.13.17 (2026-10-29)++From Drew Owens (PR #24). The mechanical BOM reads a large real assembly right, and the revision guard accepts assemblies built from referenced designs.++- BOM views beside the purchasing list: `indented` (item numbers, quantity per parent, kits and phantoms), `cutList` with a+  first-fit-decreasing `stockPlan` for extrusion, `wireList`, `orderList` (bought lines merged by supplier part number),+  `fasteners`, `totals` and `warnings`. `bom_export` gains the modes `indented`, `cutlist`, `fasteners`, `wires` and `order`.+- Every line says why it is made or bought (`makeBuyReason`). Metadata wins; otherwise the name is read: made here+  (fabricated, 3D printed, cut from), cut from stock (wire, extrusion, DIN rail, duct), a McMaster number (also filled in as+  the supplier part number, marked `supplierInferred`), a fastener, electronics, hardware or a cable, a vendor note such as+  "(vendor STEP)", or a maker's name. `totals.inferredLines` counts what was read rather than stated.+- An assembly that reads as a bought product (an imported .stp or STEP-translator model, a vendor note, a maker, a McMaster+  number) or whose children are a circuit board's footprints counts as one bought line (`inferKits`). A body-less group+  named as a library is excluded (`includeLibraries`). Stand-in geometry and items supplied with something else are+  ordered by nobody.+- Wires are measured as body volume over end-cap area, exact for a section swept along any path (the box undercounts a+  routed wire).+- `component_create` and `component_metadata` take `category`, `makeBuy`, `process`, `finish`, `unitCost`, `currency`,+  `leadTimeDays`, `stock`, `notes` and `revision`.+- Scale, measured on a 4,579-occurrence cell: the revision guard accepts components inserted by reference (they enter by+  source document version), identity lookups are indexed instead of compared pairwise, and Fusion's cloud part number and+  description reads (about 0.6 s per component) are cached per component revision or skipped with `nativeProperties:false`.+  `inspect` gains `detail:"target"` and `componentProperties`. A guarded operation on that cell went from about 20 minutes+  to about 40 s.+- The add-in is 1.0.24, so Fusion reloads the changed mechanical package; the exe embeds the new `schema.json`.++- `fusion_simulate` sweeps (standard 0.21.2): `sweep {parameter, start, stop, step, scale?}` steps a part's value (R4) or+  a model parameter (Q1.BF), and `temperatures {start, stop, step}` the temperature; each run is its own signal with+  `step` ("R4 = 300, T = 85"), run in one ngspice batch with alter, altermod and option temp. A partly modelled sheet now+  runs and names the parts it left out in `notSimulated` (BQ25792: 89); a sheet with no modelled part refuses with no_model.++## 1.13.16 (2026-10-29)++- Engine 0.19.0 (standard 0.22.1): review_board's rule classes from standard-lane's fix.+- `fusion_teardrops` (the standard's teardrops): the engine plans each teardrop to hold the board's clearance; Fusion+  draws them as named solid polygons (rank 1, no thermals, so Fusion never asks for a signal) and reads them back+  (Fusion writes a drawn polygon as <polygonpour>), undoing all on a mismatch.+- `fusion_panelize` (the standard's panelize): the engine plans the panel (V-score or mouse-bite tabs, rails, tooling+  holes, fiducials, JLCPCB's rules); Fusion builds it as a new EAGLE board from the open board's source, copy k's+  parts and nets renamed _k, the copies' outline left to the panel's rout path and the board shape recomputed, and+  opens it as a local design. 336 verbs.++## 1.13.15 (2026-10-29)++- `fusion_not_supported`: the standard verbs that belong to Altium's own machinery (Altium 365, its script agent and+  .NET extension, integrated libraries, OutJobs, symbol display modes, library defaults) answer not_supported with what+  Fusion does instead, under their own names (fusion_a365_status ...) or through this verb, which lists them.+- `fusion_swap_footprint` (the standard's swap_footprint): a part on a board kept as EAGLE source takes another+  footprint at the same place and turn, its pads rewired from assigns by pad number; designator picks the part.+- `fusion_set_models` and `fusion_add_models` (the standard's): a component keeps one footprint, or gains more as+  further devices, pins joined to pads by number (repeated numbers' N@2 pads too); a footprint already attached is+  skipped. set_params joins a footprint the same way. 334 verbs.++## 1.13.14 (2026-10-29)++- Engine 0.18.0 (standard 0.21.0). plan_route and the other planners take the track width from the board's minimum+  width rule (msWidth) when no net class sets one, instead of the engine's 0.25 mm default.+- `fusion_footprint_from_land_pattern` (the standard's footprint_from_land_pattern): the engine lays out a datasheet's+  land pattern (chip, dual, SOT, quad, BGA, exposed pad) and the bridge writes it into a .lbr offline: pads with EAGLE+  roundness from the engine's cornerRatio, silkscreen on tPlace, the fab outline on tDocu, the courtyard on tKeepout.+  New libraries now carry the tDocu and bDocu layers.+- `fusion_build_board` (the standard's build_board): a new board from a parts list and a netlist, written as EAGLE+  source (outline with rounded corners or points, footprints by origin, pad nets), opened in Fusion as a local design+  dialog-free and read back pin by pin (wrongPins, missingParts, unconnected).+- `fusion_test_board` (the standard's test_board): footprints from a .lbr on a new board, or appended to an existing+  .brd with designators continuing; a plain rectangular outline grows to hold appended parts, and parts outside any+  other outline are named. assigns and stubs apply to the last part.+- `fusion_import_part` (the standard's import_part): the footprint and symbol spec files Altium's bridge takes go into+  one .lbr offline (pins joined to pads by number, a repeated pad number as N@2 on the same pin, params and comment as+  attributes), preflighted before writing; a STEP is minted and bound to the component dialog-free. Importing again+  replaces the footprint, the symbol and the 3D body. 330 verbs.++## 1.13.13 (2026-10-29)++- Engine 0.17.2 (standard 0.20.2). The checks get the board's minimum track width and drill (EAGLE's msWidth,+  msDrill) as the standard's width and hole-size rules, and review_board and board_report are told EAGLE's DRC always+  checks shorts: BQ25792's three missing_critical_rules errors were rules Fusion has.+- `fusion_board_report`: the JLCPCB assembly section gets the BOM lines with no LCSC number (as fusion_assembly_check+  does), and the DRC section reads Fusion's violation and airwire counts.++## 1.13.12 (2026-10-29)++The standard's pair and length planners, the schematic checks and the design review and report from the shared engine 0.17.0 (standard 0.20.0). 326 verbs.++- `fusion_route_pair`: a differential pair planned as a pair, one centreline with each net offset at width + gap+  (or the gap for diffOhms from the stack-up): routeNet for each net, widthRule for fusion_add_rule, skewMm, and the+  problems that stop it. On BQ25792's D pair it finds the pads on swapped sides at the two ends.+- `fusion_length_tune`: a serpentine in a net's longest straight track to reach targetMm or match another net,+  answered as remove (fusion_remove_items) and the routeNet that replaces it. On BQ25792 it took SCL from 53.613 to+  exactly 55.6 mm, placed with no split and no airwire (and put back).+- `fusion_schematic_review`: every placed pin's electrical type against the netlist (power pins on no net, outputs+  driving each other, open inputs, single-pin nets, missing decoupling). BQ25792: no errors; SW1 pin 3 open and no+  decoupling cap on VBAT near U$1/U$3.+- `fusion_pin_pad_check`: each symbol's pins against its footprint's pads, and parts only on the sheets or only on+  the board. BQ25792: 103 parts match; SW1's mounting lugs (pads 4, 5) have no pin; the logos are board-only.+- Package-less symbols (EAGLE's supply symbols) are not parts to these checks.+- `fusion_review_board`: thirteen design-review checks over one read of the board, errors first, with what was not+  judged and why.+- `fusion_board_report`: one self-contained HTML page with every check the shared engine has, Fusion's own DRC and a+  picture of the board (BQ25792: 10 sections, 523 KB). Fusion stores its DRC result in the board: drc:false skips it.+- The engine verbs' replies no longer carry empty `moveArgs`, `remove` and `routeNet` fields (1.13.11 added them as+  null to every reply).++## 1.13.11 (2026-10-29)++Six more of the standard's verbs, engine 0.14.1 (standard 0.17.1). 320 verbs.++- From the shared engine:+  - `fusion_auto_classes`: GND, Power, Clock, HighSpeed classes and pairs from the net names; a proposal, and+    apply:true writes the classes that carry a width as Fusion net classes (fusion_add_rule);+  - `fusion_silk_designators`: every designator one size, upright, beside its part and clear of pads, bodies and+    each other; landed with fusion_apply_silkscreen unless dryRun (Fusion's designator boxes are computed from the+    text for the engine);+  - `fusion_find_space`: free spots for a part near another, nearest first, or check:true for overlaps;+  - `fusion_check_orientation`: 2-pad parts whose turn would shorten their airlines.+- Native:+  - `fusion_jlcpcb_order`: the JLCPCB fab check, Gerber zip, JLCPCB BOM and CPL, assembly-tier check and the order+    form values, in one folder with every issue in one list;+  - `fusion_sch_zoom`: parts highlighted and framed on their sheet, with a picture of the view (no foreground).+- `fusion_apply_silkscreen` resizes a text where it stands, before moving it (picked at its new place, the size+  did not land: BQ25792's SW1), and undoes every command when any text does not read back as asked (before, only a+  copper change was undone).+- The standard's app verbs Fusion answers under its own names are mapped in the standard's equivalents:+  animate_view (fusion_view), window_info (fusion_check_dialogs), license (fusion_account), eval+  (fusion_run_modeling_script, Python with Fusion's API), open_project (fusion_open_cloud_file).++## 1.13.10 (2026-10-29)++Two more of the standard's checks from the shared engine 0.12.2 (standard 0.15.2). 314 verbs.++- `fusion_net_lengths`: each routed net's length by layer with its vias, the skew of each differential pair (by the+  nets' names) and the spread of matched-length groups.+- `fusion_assembly_check`: the board against JLCPCB's Economic and Standard assembly tiers; the BOM lines with no+  LCSC number come from the board's own part attributes.+- Engine 0.12.1-0.12.2: a route with no path says why at each end (`ends`, `avoidExempt`) and, when only an avoided pour blocks it, gives the path through it (`withoutAvoid`); assembly_check counts pads sharing one centre as one land and leaves pad-less parts out.++## 1.13.9 (2026-10-29)++Circuit simulation with the ngspice Fusion bundles (the standard's #23). 312 verbs.++- `fusion_export_spice`: the design's SPICE netlist from EAGLE's own EXPORT SPICENETLIST (no dialog), ngspice dialect,+  with its elements, the parts that have no SPICE mapping, analyses and includes.+- `fusion_simulate`: op, dc, ac (dec, oct, lin), tran or raw SPICE text, probes by net or source current, signals as+  x/y data (AC in dB with the unwrapped phase in degrees). The netlist gets the analysis and a .control block and+  Fusion's bundled ngspice 41 runs it in batch mode in a child process, so Fusion's simulation dialog never opens. A+  part with no SPICE mapping refuses with `no_model`. Checked on an RC low-pass (1k, 100n): -2.99 dB and -44.9+  degrees at 1.585 kHz.++## 1.13.8 (2026-10-29)++Schematic placing and wiring, and engine 0.11.0 (standard 0.14.0). 310 verbs.++- New, each read back and undone on a mismatch, no dialog:+  - `fusion_sch_place_part`: a deviceset from a library the design holds (by name) at x, y (mil), with its+    designator (the next free one for R? or none) and value; Fusion adds it to the board too;+  - `fusion_sch_connect`: a stub from each pin's outer end named for the net, with a label (port: an XREF label;+    power: a label, as Fusion's power symbols are library parts); a pin on another net is refused, never merged;+  - `fusion_sch_swap_part`: a part's device replaced in place with REPLACE; the reply lists the pins that lost+    their net.+  - Two Fusion limits found live (2706) and refused clearly instead of failing silently: a variant named with+    parentheses (Fusion's passives: CHIP-0402(1005-METRIC)) cannot be added from a text command, and a local .lbr+    is accepted by USE but not added from (add the library to the design first). `fusion_schematic_run`'s ADD has+    the same limits.+- `fusion_sch_delete_wire` deletes a labelled stub: its label goes with it (only labels of the deleted wires' nets),+  and the reply lists `labelsRemoved`. Before, the read back undid it.+- `fusion_export_ipc2581` is written by the shared engine (IPC-2581C, valid against the schema): the same copper as+  Fusion's own writer on BQ25792 (920 pads, 577 lines, 176 holes, 43 pour contours, 50 nets); parts with no pads+  (logos) are left out.+- Engine 0.10.4: `fusion_plan_route` smooths grid staircases into straight and 45-degree segments (BQ25792's N$15: 8+  corners, 13.9 mm, its via where the designer put it, routed with no split and fewer DRC entries than the+  original), echoes `avoidPours` and `pourCost`, and exempts a pour holding the route's own end pad.++## 1.13.7 (2026-10-28)++Engine 0.10.3 (standard 0.13.3) and `fusion_diff_pairs`. 307 verbs.++- New: `fusion_diff_pairs`, the board's differential pairs as Fusion keeps them, by the nets' names (NAME_P/NAME_N,+  P/N, +/-, DP/DN). Fusion has no pair object, so defining or removing a pair is refused with how to rename the nets.+- Engine 0.10.2/0.10.3: `fusion_plan_fanout` skips routed pins, checks its stubs and vias against other nets' tracks,+  arcs and vias, keeps an exposed pad's grid off existing holes and names the pours it crosses;+  `fusion_plan_route` takes `avoidPours` as a list of nets and a soft `pourCost`.+- Checked live on BQ25792's N$15: with the original via size (0.55/0.35) on a 0.1 mm grid, the plan puts its via+  where the designer did, (35.7, 1.8), and `fusion_route_net` places it with no split net and no airwire.++## 1.13.6 (2026-10-28)++Engine 0.10.1 (standard 0.13.1) and three more of the standard's verbs. 306 verbs.++- New:+  - `fusion_read_board`: the live board in one round trip, as sections (components, nets and classes, layers, copper,+    rules, occupancy, outline), each list capped at `limit`;+  - `fusion_add_rule`: a scoped width, clearance or via-drill rule as an EAGLE net class. A net scope gets its own+    class (`Adom_<name>`), each net joined with one pick on its wire; read back, undone on a mismatch; `remove` puts+    the nets back in the default class;+  - `fusion_estimate_cost`: the board's quote numbers and a rough price table, from the shared engine.+- Engine 0.10.1: `fusion_plan_route` checks a through via on every copper layer, names the pours a route crosses+  (`crossesPours`) and can keep out of them (`avoidPours`); `fusion_check_clearance` lists stacked parts apart;+  `fusion_place_decoupling` takes supply nets only and leaves room for the IC's fanout.++## 1.13.5 (2026-10-28)++Routing and placement from the standard's shared engine (adom-eda-checks 0.8.0, standard 0.11.0), and `fusion_route_net` on+any board. 303 verbs.++- `fusion_plan_route` is the shared engine's (#21): A* on any copper layers listed, pads by their real outline, planned to+  the board's strictest copper clearance and its copper-to-edge rule, so the plan is one `fusion_route_net` accepts.+  `routeNet` carries `boardId` and `expectedRevision`. Fine-pitch pads need `gridMm` 0.1.+- New, read only, from the shared engine (#22):+  - `fusion_check_clearance`: part-to-part clearance by courtyard (with 3D bodies) or by pad copper;+  - `fusion_place_decoupling`: a plan placing an IC's decoupling caps beside its power pins, as `fusion_move_parts`+    arguments, checked with placement_check;+  - `fusion_plan_fanout`: a part's fanout as `fusion_route_net` calls, with the conflicts against other nets' pads.+- `fusion_route_net` works on any board, not only two-layer ones without pours:+  - any copper layer, by name (In1.Cu) or number; a through pad or via is on every layer of the stack;+  - pours are repoured round the new copper, and a route that cuts another net's pour in two is undone (`splits_net`;+    `allowSplit` keeps it). On BQ25792 a planned N$15 cut VBAT's pour and was undone;+  - curved tracks, footprint and board copper, keepouts (tRestrict, bRestrict) and footprint mounting holes are+    obstacles; pads are measured by their real outline;+  - `viaSize` is accepted for `viaDiameter`; a clearance refusal names the copper it would hit and where.++## 1.13.4 (2026-10-28, public)++The standard's shared engine 0.5.1 (standard 0.8.1) makes 3D bodies, and placement checks know about molecules.++- `fusion_generate_body` uses the shared writer for chip, soic, qfn, qfp, sot23, dfn, bga, melf, ecap, crystal and+  header: the STEP is written on the Fusion machine and Fusion is not needed. It matches the four bodies Fusion's+  generator made for standard #20 (0603, SOIC-8, QFN-32 with its exposed pad, QFP-48), and its STEP opens in Fusion+  and in OCCT. Any other family, or `generator: "fusion"`, still goes to Fusion's package generator.++- `fusion_generate_body` gives each package generator its pins the way that generator counts them. SOIC-8 came out+  with 4 leads and QFP-48 with 24: SOIC, SOJ, SON, DIP and the oscillators take the total, QFP and PLCC the two+  opposite sides together, QFN each side (read from Fusion's generator scripts). `D2`/`E2` now draw the exposed pad+  (the generator's thermal pad; QFN calls it `D1`/`E1`).+- `fusion_generate_package {outputStep}` makes the STEP's folder first. Fusion's STEP export writes nothing into a+  missing folder, and the verb then failed writing its manifest. It now also refuses if no STEP was written.++- `fusion_placement_check` lists a part under a raised molecule as `stacked` (pads+  compared one by one, bodies in 3D) instead of a courtyard overlap. On BQ25792: 39 overlaps and 78 stacked, where+  1.13.3 reported 117 overlaps.++## 1.13.3 (2026-10-28, public)++The standard's shared engine (adom-eda-checks 0.4.0, standard 0.7.0) plans the vias, and two placement checks are new.+300 verbs.++- New, read only, from the shared engine and `fusion_bodies`:+  - `fusion_height_check`: each part's height, parts over a limit or under a lid region, bodies that collide or+    come too close; parts without a 3D body are listed, never passed;+  - `fusion_placement_check`: courtyard overlaps, parts off or over the edge, pads near the edge, parts on a+    mounting hole.+- `fusion_thermal_vias` and `fusion_via_fence` are planned by the shared engine and placed by Fusion, read back and+  undone on a mismatch. The plan keeps clear of vias already in the pad, and `dryRun` answers `apply` as+  `fusion_place_vias` arguments (which now also take `size` for the diameter).+- `fusion_bodies` gives a box per sub-assembly for a part whose 3D model is an assembly (an Adom molecule: its own+  small board on pins, its connector on top), so a part under a molecule's raised board is no longer a collision+  (92 collisions on BQ25792 became 9). Heights come from the bodies themselves: Fusion's box for the whole+  occurrence was 3 mm short on the barrel-jack molecule's housing (16.7 mm, not 13.7). `parts` counts the parts.+- The checks' via size comes from the board's via rule, now passed to the engine in the standard's form.+- Every engine reply reports the engine's own `engine` string.+- The busy gate waits out the bridge's own quick reads (`document_info`, `get_app_state`) for up to 15 s instead+  of refusing the next verb. With about 90 documents open, the post-verb document snapshot can outlive the 3 s+  the window etiquette waits for it, and the caller's next verb then found it still running and got+  `main_thread_busy` (a mechanical `inspect` in the assembly campaign, behind a 4.9 s `document_info`). Real work+  in front of a verb is refused as before.++## 1.13.2 (2026-10-28, insiders)++The standard's shared writers, for files every bridge writes the same way.++- `fusion_export_gencad` is written by the EDA Bridge Standard's shared engine (adom-eda-checks 0.2.1,+  standard 0.5.1), in inches. Shapes are keyed by footprint and pad geometry, so two same-named footprints with+  different pads stay separate shapes.+- `fusion_export_dxf {layers}`: copper layers and Edge.Cuts come from the shared engine; silkscreen, fab and+  documentation layers stay on this bridge's writer, which also draws their texts.+- The engine's checks are unchanged.++## 1.13.1 (2026-10-28, insiders)++More of the standard's schematic, document and board verbs. 298 verbs.++- New, read only:+  - `fusion_schematic_data`: parts with pins (pad numbers, electrical type), gates, values and attributes;+  - `fusion_part_parameters`: attribute names across the placed parts, or one attribute's value on each;+  - `fusion_cross_check`: the schematic's designators against the board's;+  - `fusion_footprint_primitives`: one placed part's pads, wires, arcs and texts on the board;+  - `fusion_export_pdf`: every sheet as one PDF, plus the board with `board:true`.+- New edits, each read back and undone on a mismatch:+  - `fusion_doc_params`: the schematic's global attributes;+  - `fusion_sheet_params`: attributes on placed parts (the BOM write-back);+  - `fusion_sch_edit`: move, rotate, rename, re-value or delete placed parts;+  - `fusion_annotate`: numbers `R?`-style designators.+- New board furniture, each spot clear of other copper, pads, holes and the edge, read back and undone on a+  mismatch:+  - `fusion_thermal_vias`: a grid in an exposed pad;+  - `fusion_via_fence`: vias along RF or fast tracks and/or the board edge, at lambda/20 or a pitch;+  - `fusion_board_features`: mounting holes, fiducials, keepouts and a stitching grid.+- Fixed: GenCAD writes `MIRRORX FLIP` for bottom parts, matching KiCad's native GenCAD (standard #16).+- Live on fusion-lane's copy of BQ25792, with the test edits removed afterwards.++## 1.13.0 (2026-10-28, insiders)++Drew's typed mechanical layer, Fusion 2706 support, his safe-restart work, and library authoring.++### Mechanical layer (merged #22, Drew Owens)++The typed mechanical layer (`fusion_mechanical`, 61 operations; `fusion_mech_capabilities`;+`fusion_mech_operation_status`), with the exe owning validation, the durable journal and replay.+Its development history is in [docs/MECHANICAL-HISTORY.md](docs/MECHANICAL-HISTORY.md).++- The exe owns the layer's validation, durable journal and replies, as it does for the rest of the bridge; the+  add-in only runs the Fusion API work. Capabilities and operation status answer from files, so they never wait+  on Fusion's main thread.+- Readbacks the 2026-10-27 certification run needed (CSWA parts and the feature matrix, built through typed+  operations only):+  - `inspect` lists `constructionPlanes` per component, the three origin planes included, with refs. A plane+    reference can be read again after a write moves the revision, and an origin plane's ref resolves through its+    component (`originPlane` xy/xz/yz), so base planes work wherever a construction plane is accepted+    (`construction_axis` two_planes, `sketch_create`, feature tools).+  - `inspect_entity` on a sketch returns its `frame` (origin, x, y and normal in component space) and each+    profile's `centroidComponent` next to its sketch-space centroid.+  - Parameter rows name their `kind` (model or user) and the `owner` that made a model parameter (feature,+    dimension or joint, with its role), so `feature_edit` no longer needs a parameter-list diff.+  - `material_list` without `libraryId` searches the document's materials and then every loaded library; each+    row names the `libraryId` that `material_assign` needs.+- The verb suite triages the three verbs: `fusion_mech_capabilities` and `fusion_mech_operation_status` as daily+  read-only checks, `fusion_mechanical` as a negative check (an unknown operation is refused by the exe's+  validation). The typed writes are covered by the mechanical drill. On macOS the journal path is returned, not a+  `todo!()`.+- Run live since: `joint_origin_*` and `motion_link_*`. All 15 assembly campaign groups pass on Drew's laptop,+  133 more checks with no failures (PR #23). Not run live: `mcmaster_open` (interactive by design).++### Fusion 2706, safe restarts (merged #21), library authoring++- Fixed for Fusion 2706, which removed the `Electron.boardInfo` text command. On released 1.12.8 that broke+  `fusion_board_info`, `fusion_board_summary`, `fusion_export_cpl` and electronics_read's board fallback. The exe+  now builds the same answer from the board's own export: the summary, plus an XML in boardInfo's layout, so+  every consumer reads it unchanged. It also writes the pick-and-place CSV itself. On older Fusion the add-in+  path is used as before.+- Merged #21 (Drew Owens), in his words:+  The bridge no longer restarts Fusion over a busy add-in, and a restart it does need no longer kills Fusion over+  unsaved work.+  - A busy add-in is never mistaken for a missing one. While a long native Fusion call holds the add-in's main+    thread, not even `/status` or `/health` answers, and the gate read that silence as "the add-in was installed+    while Fusion was running" and restarted Fusion. On a person's own PC that killed Fusion with their documents+    open six times between 2026-10-14 and 2026-10-28 (a 93 s script was in flight on 10-28). Now silence counts as+    work whenever there is evidence the add-in is loaded: one of the exe's own requests to it is still in flight,+    or it answered earlier inside the same Fusion process and its port still takes connections. The verb gate, the+    timeout diagnosis, the readiness launch observer (which restarted Fusion after about 3 minutes of silence) and+    a warm `fusion_start` all ask for that evidence first and answer `fusion_addin_busy`. `fusion_readiness` and+    `fusion_state` report it as `addinBusy`, and the dashboard no longer restarts over it. A request in flight also+    counts as a long operation for the hang verdict.+  - `restartPolicy` `auto` (the default) stops short of losing work. When the add-in cannot save, Fusion is closed+    the way a person closes it instead of killed: it closes at once when nothing is unsaved, and a save prompt for+    a document the bridge did not make (or a never-saved document) ends the restart with `restart_needs_decision`,+    with nothing killed or discarded. For 30 minutes after that the restart is asked for instead of retried. A stop+    that did not finish is no longer escalated to a kill. The old behaviour is `restartPolicy: force`, for a machine+    only an AI drives. The ledger's restart summary now says what happened: it said "Documents were saved first"+    when the save step had failed and Fusion was killed.+  - `fusion_stop` waits for heavy designs: up to `closeTimeoutSec` (default 120; it was 15 s). A save prompt for a+    document the bridge made is answered Don't Save; one for anyone else's work is cancelled and the stop fails+    with `unsaved_work`.+  - Documents a caller opens are no longer registered as bridge scratch. Any document that appeared during a+    window-raising verb was registered, so a user's assembly reopened with `fusion_open_by_urn` became "the+    bridge's": its save prompt would be answered Don't Save and a restart could discard it. Now only documents a+    verb made (not saved cloud documents, which were opened) and the bridge's own Save As are registered, and+    nothing Fusion opens at launch. The registry evicts its oldest entry when full; it used to evict the+    alphabetically first.+- New, offline on .lbr files, each change preflighted before it is written (the old file kept as .bak):+  - `fusion_create_footprint`, `fusion_create_symbol`, `fusion_read_symbol`, `fusion_find_symbol`;+  - `fusion_copy_footprint`, `fusion_rename_footprint`, `fusion_remove_footprint`, `fusion_xcopy_footprint`;+  - `fusion_clone_symbol`, `fusion_rename_symbol`, `fusion_remove_symbol`;+  - `fusion_set_params`: attributes, and joining a symbol's pins to a footprint's pads by number.+- The daily verb suite runs on fusion-lane's copy of BQ25792 (Default Project/fusion-lane-tests), never on the+  owner's design.++## 1.12.8 (2026-10-28, insiders)++KiCad's remaining core and app proposals, and a close that never saves unasked. 271 verbs.++- Fixed: `fusion_close_document {save:false}` on a saved cloud document with unsaved changes used to save a+  new version first, silently, because Fusion asks to save even when told not to. It made BQ25792 v228 for a+  caller who meant to discard. Such a close is now refused (`unsaved_cloud_document`) and nothing is+  written, unless `save:true` or `saveToClose:true`. The bridge's own internal closes pass `saveToClose`.+- New:+  - `fusion_cross_probe`: a schematic part to its board part and back, by designator; `select` highlights both.+  - `fusion_import_svg`: SVG artwork onto silkscreen, mask, paste or documentation layers. Fusion's POLYGON+    asks for a signal name in a modal, so filled shapes are drawn row by row with RECT. Holes follow+    even-odd, bottom layers are mirrored, and copper is refused before any command runs.+  - `fusion_copy_routing`: tracks and through vias by an offset, nets remapped through paired parts or a+    netMap. A copy that would land on another net is refused before drawing; Fusion's DRC runs before and+    after, and any new error undoes it.+  - `fusion_set_layer_count`: 2, 4, 6 or 8 copper layers through the board's design rules, with the+    thickness kept; layers still carrying copper are refused.+  - `fusion_project_info`, `fusion_project_snapshot` (EAGLE XML, PNGs and PDFs in a dated folder) and+    `fusion_project_create` (an empty schematic and board opened as a new design).+  - `fusion_export_library_part` and `fusion_edit_footprint`: offline .lbr work, preflighted before writing.+  - `fusion_project_rename`: a design kept as EAGLE files (folder and files renamed together); refused while open+    in Fusion, and for a cloud design, which Fusion's data panel renames.+  - `create_part_project`: the standard's name now runs `fusion_make_test_project`.+- The checks engine is `adom-eda-checks` 0.1.4 (standard 0.4.5): copper-only clearance (#13) and each pour+  layer listed once in `current_capacity` (#15).+- Daily suite: 131 pass on DESKTOP-BAR6S0F; the 5 failures are the APS verbs without the APS sign-in.++## 1.12.7 (2026-10-27, insiders)++The standard's fab exports, and read_footprint. 261 verbs.++- New:+  - `fusion_export_odb`: Fusion's own ODB++ (Electron.mfgodb with the JLCPCB CAM job), packed as zip, tgz or a folder;+  - `fusion_export_ipc356`: the IPC-D-356A netlist for bare-board electrical test (317 and 327 records, metric,+    long net names as NNAME aliases);+  - `fusion_export_gencad`: GenCAD 1.4 (outline, pads and padstacks, shapes, components with bottom parts mirrored,+    devices, signals, routes and vias);+  - `fusion_export_ipc2581`: IPC-2581 revision C, valid against the IPC-2581C schema (layers and stack-up,+    packages, components and BOM, nets, pads, traces, vias, the poured copper island by island, drills). It is+    mode ASSEMBLY: mask, paste and silkscreen are not in it, so a fab order still goes through ODB++ or Gerbers;+  - `fusion_read_footprint`: one footprint's pads, layers, courtyard box, graphics per layer and 3D packages, from a+    .lbr or (by `libId` "Lib:Name") from the libraries the open board embeds.+- Fab text is ASCII: unit signs in values are named (10kΩ becomes 10kohm in GenCAD and IPC-356, `\U+03A9` in DXF).+  Before, a board DXF with an Ω on the silkscreen failed with a codec error.+- The checks engine is now `adom-eda-checks` 0.1.2 (standard 0.4.3). Fusion passes only copper clearances to it,+  since 0.1.2's `min_clearance` also takes mask, dimension and restrict clearances (standard issue #13).+- Daily suite: 121 pass on DESKTOP-BAR6S0F; the 5 failures are the APS verbs without the APS sign-in.++## 1.12.6 (2026-10-27, insiders)++- The board verbs bring the named design's board forward when its schematic, 3D PCB or another document is in front,+  instead of refusing with "Activate a PCB board" (an error the bridge can fix itself). Found by running the checks+  right after the daily suite, which leaves the 3D PCB in front.++## 1.12.5 (2026-10-27, insiders)++The checks tier through the EDA Bridge Standard's shared engine. 256 verbs.++- `adom-eda-checks` 0.1.1 is vendored from the standard (0.4.2, commit 680ab69; `rust/vendor/adom-eda-checks/VENDOR.md`+  says how to update it, never by editing the copy) and linked into the exe.+- New: `fusion_copper_balance`, `fusion_return_path`, `fusion_impedance`, `fusion_current_capacity`, `fusion_fab_check`.+  Their input comes from one export of the live board (the board model, stack-up, Fusion's pour fills, the rules+  with copper clearances in the standard's `{kind: clearance, clearanceMm}`, the silkscreen), and the engine's+  follow-up verbs come back as this bridge's (`fusion_apply_pours`, `fusion_add_rule`).+  `fab_check {vendor}` fetches the record for the board's copper layer count from adom/pcb-design-rules.+- On BQ25792: JLCPCB's 4-layer record finds R3.1's pad 0.405 mm past the board edge (minimum 0.2 mm, routed edge),+  and 5 A on VBAT needs 2.8 mm of outer copper where the narrowest is 0.81 mm.+- Daily suite: 117 pass on DESKTOP-BAR6S0F; the 5 failures are the APS verbs without the APS sign-in.++## 1.12.4 (2026-10-27, insiders)++Standard parity, round three: the verbs credited by name now answer the standard's shape, and eight more. 251 verbs.++- Now in the standard's shape:+  - `fusion_export_dxf` with `layers` writes board layers to DXF, one file per layer (outline, copper with track+    widths, pads, vias, pour fills, silkscreen and fab with readable texts and resolved placeholders); without+    `layers` it is still the mechanical DXF;+  - `fusion_plan_route` takes `from`/`to`/`widthMm` and answers `found` and `routeNet` (two-layer boards);+  - `fusion_document_info` adds kind, saved, modified, path, version and project;+  - `fusion_close_all_documents` keeps unsaved work by default: a changed document stays open (keptOpen) unless+    `save` or `discardUnsaved`; scratch documents close only with `includeScratch`. Before, a changed saved document+    was saved (a new cloud version) and closed.+- New:+  - `fusion_render_board_3d` (Fusion's 3D view of the design, its 3D PCB shown when needed and the user's tab put+    back; transparent background);+  - `fusion_generate_body` and `fusion_library_views` (the standard's names over the package generator and the+    library captures, which open the library themselves);+  - `fusion_edit_parts` (value, designator, fields, lock; DNP and BOM flags refused, Fusion keeps them in variants);+  - `fusion_align_parts` (footprint box or anchor; refuses only the overlaps a move makes);+  - `fusion_remove_graphics` (board graphics by id, layer or kind; a dry run lists the ids);+  - `fusion_remove_parts` (deleted in the schematic: Fusion ignores a part deleted on the board).+- Learned live: `LOCK -` is not a command (a shift-click LOCK unlocks); a field the library part defines cannot be+  removed from the board; Fusion's `Electron.mfgodb` needs more than a CAM job (ODB++ is not offered yet).+- Daily suite: 111 pass on DESKTOP-BAR6S0F; the 5 failures are the APS verbs without the APS sign-in, and one test+  of mine corrected (plan_route on the four-layer BQ25792 is refused as two-layer only).++## 1.12.3 (2026-10-27, insiders)++- New `fusion_update_board_from_eagle {brdPath, expectDocument, save?}` (page issue #125, item 4): makes the open+  design's board the board in an EAGLE .brd (or .fbrd) in place, so a re-run updates the same design instead of+  importing another. Parts move and turn by name; tracks and vias are ripped up and drawn from the file; pours, the+  outline, holes and net-less copper are replaced; then the whole board (parts, copper, pours, outline, holes, nets)+  is read back against the file. With `save:true` it is saved in place only after an exact read back; otherwise+  nothing is saved and the reply says to close without saving. A file that adds or removes parts or changes a net's+  pads is a schematic change and is refused with `schematic_differs`. Not synced, and named in `notSynced` when the+  file differs: silkscreen and documentation, design rules, name and value positions. Fusion's export writes a pour+  as `<polygonpour>`, a file as `<polygon>`: both are compared by net, layer, pen, isolation, rank and outline.+  Verified live on a design saved to Default Project / fusion-lane-tests: J2 moved, NET_1 routed on both layers+  through two vias, a pour and a hole, then a second file applied with `save:true`: board v1 to v2 of the same+  lineage, the folder still holds one .fprj, one .fsch and one .fbrd, and the design reopened from the cloud shows the+  second file's board.+- `fusion_open_cloud_file` by name opens the electronics design (.fprj) when one has that name: opening the+  board or schematic file of a saved design raised Fusion's "links to multiple Electronics designs" chooser, which+  cannot be answered headlessly. It falls back to the plain name match when there is no design of that name;+  `fileExtension` still picks a file outright.+- Checked for #125: closing a never-saved imported design without saving writes nothing to the hub (no+  Untitled file appears in the project).+- Schematic edits honour `save: true`: after a read-back edit the design is saved in place (as+  `fusion_save_document`). `save` defaults to false, as the standard's conventions now allow, because each Fusion+  save is a new cloud version; every edit verb's describe says so. A never-saved design answers `saved: false` with+  the save's reason (with several open documents named Untitled, that reason can name the wrong one).++## 1.12.2 (2026-10-27, insiders)++The EDA Bridge Standard's schematic verbs (`sch_*`, agreed in standard 0.2.0): all 21, each read back on a live+design and undone on a mismatch. 243 verbs in the catalog.++- Reads, from Fusion's own export of the design's schematic whichever tab is in front (the tab is put back), or+  from a .sch/.fsch on the Fusion machine: `fusion_sch_items` (wires, buses, entries, labels, power ports,+  junctions, texts, module instances, each with an id built from its kind and position, since Fusion stores none),+  `fusion_sch_pins` (connection point, pad numbers, type, side, net, wires and pins on its segment),+  `fusion_sch_trace_point`, `fusion_sch_page`, `fusion_sch_hierarchy` (modules), `fusion_sch_sheet_pins`+  (module ports). Pin positions: every connected pin of BQ25792 and the routing fixture (274) sits exactly on a+  wire end of its own net segment. Fusion's ULP pin coordinates count the part's offset twice, so they are not+  the reference.+- Edits: `fusion_sch_text`, `fusion_sch_junction`, `fusion_sch_delete_wire` (junctions left joining fewer than+  three items, pins counted, go too), `fusion_sch_connect_pins`, `fusion_sch_split_wire`, `fusion_sch_bus`,+  `fusion_sch_bus_entry`, `fusion_sch_connect_to_bus`, `fusion_sch_edit_label`, `fusion_sch_move_region`,+  `fusion_sch_fix_connectivity`, `fusion_sch_reset_fields`, `fusion_sch_create`, and `fusion_render_schematic`+  (EXPORT IMAGE, with pixel baselines: drift, changed region in mm, a diff image).+- Refused with the reason: setting the page (a frame part and design attributes Fusion's commands do not reach),+  sheet-pin edits (module ports), `fusion_sch_update_from_library` (Fusion's Library Manager asks per part),+  renumbering sheets, `junction:false` on a split.+- What Fusion taught (in sch_script.py): SET CONFIRM only answers a question when it is on the same command line;+  a moved pin landing on another net makes Fusion ask to merge them, so moves answer No and refuse with+  `would_join_nets`; a group's outline snaps to the sheet grid (`box_edge_off_grid`); a scripted group MOVE leaves+  parts and global labels behind, so they are moved by name; a junction click on its centre takes a wire end;+  TEXT uses the current layer; edits run at a 0.001 mm grid and put the user's sheet and tab back.+- Undo never takes the user's own work: nothing is undone when Fusion made no change; steps are undone one short+  of the count and then one at a time, and if the starting revision never returns every step is redone and the+  edit reported as left in place.+- ab budgets: the routing and schematic edit verbs get 120 to 300 s instead of the 60 s default.+- Known: once, moving a wire end onto another net raised a Fusion "Error" box (closed by the dialog backstop; the+  verb timed out); not reproduced.++## 1.12.1 (2026-10-27, insiders)++The EDA Bridge Standard 0.1.1 settlements (standard issue #2).++- `isolatedCopper` (`{net, layer, at:{x,y}, areaMm2}`) in `fusion_routing_state`: a group of only poured copper+  (an island, or a pour that reaches no pad) is listed there and not counted in `unconnected`; a stray track or+  via still counts. `floatingPourIslands` stays beside it.+- A custom pad's `copperPoints` is one ring (the largest drawn polygon), as the schema now says; a pad that+  gathers several also lists them under `copperOutlines`. `polygons[].kind` is `zone` (a pour) or `graphic` (drawn+  copper, `source:"footprint"` inside a part).+- New `fusion_apply_silkscreen`: designators and values moved, sized, turned or hidden, free texts and lines added,+  earlier ones removed by `fusion_silk_state`'s new `raw` handles. Each pick is made with only the target's layer+  displayed; the layer display is restored one layer at a time (a DISPLAY that names the origin layers drops every+  layer after them); if copper, parts or the outline move, every command is undone. Verified on BQ25792: IC1 and+  R2 names moved, sized and turned exactly, C1's value hidden and shown, revision unchanged, display as before.++- Daily verb suite: 94 pass on DESKTOP-BAR6S0F (the new reads, select_net, layer visibility, board_outline, run_erc+  and the aliases run daily on BQ25792); the 5 failures are the APS verbs on a box without the APS sign-in.++Standard parity: 20 more verbs (222 in the catalog; Fusion covers 77 of the standard's 182, was 56).++- `fusion_set_track_width {nets | netClass, layer?, widthMm}`: each track is picked with only its layer displayed,+  at the point along it farthest from other copper (a midpoint pick took a neighbour), in up to three read-back+  passes; only the asked tracks may change, and only in width, or every change is undone. A stub lying wholly+  under a wider track of its own net, or inside its own pad, is reported as `covered`.+- `fusion_remove_items {tracks:[{start,end,layer}], vias:[{position}]}`, given as `fusion_routing_state` returns+  them; read back as the board minus exactly those, or undone. `results[]` per item.+- `fusion_set_outline {outline:{rect:[x0,y0,w,h], cornerRadius?} | {points}}` replaces the Dimension-layer outline+  (rounded corners are arcs: Fusion's WIRE takes the angle bare, `+90`; `$90` and `@r` are ignored without an+  error). The outline is read back closed with the asked edges, or every command is undone. `fusion_board_shape`+  is its rectangle form; `fusion_board_outline` reports the edge (Fusion's Gerbers export layer 20 as the outline).+- `fusion_set_layer_visibility {layerId, displayed}`, read back from the board's layer flags.+- `fusion_select_net {net, zoom?}` highlights a whole net (Fusion clears a finished SHOW's highlight at once, so+  SHOW is left waiting for a click: a command-line prompt, not a dialog) and frames it.+- `fusion_run_erc`: Fusion's ERC on the board's schematic (its tab brought forward, the board's put back), every+  message read from `UL_SCHEMATIC.errors` with class, code, sheet and position.+- `fusion_autoroute {nets?}`: Fusion's autorouter on the given nets, or every net with unconnected copper; existing+  copper is kept (read back, or undone); DRC before and after. Refused before anything runs when a copper layer in+  use is off in the board's autorouter setup: Fusion would ask "used but not enabled, run anyway?", which neither+  SET CONFIRM nor AUTO LOAD answers. Verified on the routing fixture: 6 unconnected to 0, DRC 0 errors.+- Standard names answer through the bridge's own verbs (marked `aliasOf`): status, save, run_script, run_command,+  list_commands, dialog_log, signin_status, license_status, open_document, show_3d_chip. `fusion_check_dialogs`+  is now in the catalog.+- `fusion_export_optimized_glb {compress: draco | quantize | none}` passes the STEP service's compression override+  (page issue #113): `none` gives a plain GLB that wiki README and widget frames can load, since they cannot reach a+  Draco decoder. Omitted, a molecule is Draco-compressed as before.++## 1.12.0 (2026-10-27, insiders)++The board model, to the [EDA Bridge Standard](https://wiki.adom.inc/adom/eda-bridge-standard) (fusion-lane thread).+Needs AI Flow 0.2.22 or later for its Fusion lane (a pad's `name` is now its own; `key` is `U1.3`).++- The daily verb suite now runs 20 of the new verbs on the canonical BQ25792 board (the board model, stack-up,+  netlist, pours, the reads, 3D bodies, the BOM's part numbers, the board_summary alias): 83 pass on+  DESKTOP-BAR6S0F; the 5 failures are the APS verbs on a box without the APS sign-in.+- Release exes are signed through Azure Trusted Signing (`tools/sign_pe.py`, from the KiCad bridge's signer).++- `fusion_routing_state` returns the standard's board model (`model: "eda-bridge-standard/board 0.1"`),+  computed from Fusion's own board export in the background:+  - millimetres, Fusion's board frame, y up; copper layers named `F.Cu`, `In<n>.Cu` (by stack order) and+    `B.Cu`, `*.Cu` for a through pad; `copperLayers` lists the stack;+  - `tracks`, `arcs` (center, radius, startAngle, endAngle counterclockwise), `vias` (position, size from+    the board's restring rules when the via leaves it to them, drill, layers), `pads` (ref, name, x, y,+    sizeX, sizeY, rotation, layer, drill, net, shape), `components` (ref, x, y, rotation, side, pattern,+    has3d), `polygons`;+  - a custom-shape pad is its bounding rectangle: Fusion's footprint `polygonshape` copper joining pads+    (the CSD17581Q3A drain joins pads 5 to 9, each 0.127 mm alone) folds into every pad it touches, with+    the real outline kept as `copperPoints`;+  - net-less copper (board copper, free footprint copper) is kept with an empty net;+  - the outline as `outlineEdges` with arcs, cutouts in `outlineCutouts`, and `outline` sampled every 2+    degrees; `outlineClosed` and `outlineProblem` say when it is not closed;+  - `unconnected` and `splitNets` from the copper itself (Fusion's fill included; slivers a pour leaves+    are `floatingPourIslands`, not missing connections); Fusion's ratsnest is `fusionAirwires`, and the+    hint explains a difference;+  - `revision` hashes copper, parts and outline only (silkscreen, rules and the ratsnest leave it alone).+  - The AI flow's keys stay: `segments`, `elements`, `airwireCount`, `remainingNets`, each pad's `at`,+    `radius`, `layers` and its `key` (`U1.3`), each via's `at` and `diameter`. **Changed:** a pad's `name`+    is now its own name (`3`) as the standard says, with `REF.PAD` under `key`; the old per-net rows moved+    from `nets` (now the list of net names) to `netRows`.+  - Verified on the BQ25792 charger (109 parts, 304 pads, 4 layers, 38 pours): every pad's position, size,+    rotation, layer and drill equals Fusion's own (a ULP dump of every contact), live and offline.+- New `fusion_layer_stack`: the stack-up from Fusion's Layer Stack Manager data (copper um, dielectric um+  and Dk x 1000 below each layer, prepreg or core, total), in the background. Falls back to the design+  rules and says the dielectric constant is unknown.+- `fusion_pour_state` adds `zones`: each pour's fill island by island with its holes.+- New `fusion_netlist`: every net with its pads (`U1.3`), live from the board or from a `.sch`/`.fsch` file+  without Fusion (`schPath`); `net` for one net, `expect` to compare pin by pin.+- New `fusion_read_sheet_file`: an EAGLE `.sch` (or the `.sch` in a `.fsch`) read in the exe, no Fusion: parts+  with value, part number, library, sheet and position, and pins with pad and electrical type.+- New `fusion_bodies`: each part's 3D body as a box from the 3D PCB (footprint rectangle, height above the+  surface, leads past the far side for through-hole parts), `noBody`, and `suspect` for a model off its+  footprint, floating or sunk.+- Standard names as aliases: `fusion_launch`, `fusion_board_summary`, `fusion_export_gerber`,+  `fusion_dismiss_dialogs`, `fusion_install` (the reply carries `aliasOf`).+- Board reads in the standard's names, all from the same background export, in mm: `fusion_component_data`,+  `fusion_component_pins`, `fusion_list_nets`, `fusion_net_connections` (with each net's airline length, the+  minimum spanning tree over its pads), `fusion_list_designators`, `fusion_layers`, `fusion_copper_layers`,+  `fusion_layers_in_use`, `fusion_read_rules` and `fusion_rules_by_kind` (Fusion's rule manager plus the classic+  values), `fusion_silk_state`, `fusion_net_classes`.+- `fusion_run_drc`: Fusion's DRC on the live board with every violation (rule, severity, layer, position,+  approved), no revision guard. `fusion_repour`: refill every pour and read the copper back. `fusion_zoom_to`:+  frame a rectangle, parts or a net.+- **Fixed: DRC errors and warnings were swapped.** Fusion's ULP gives a violation's type as 1 for a warning and+  2 for an error (and its state as 2 when approved); the bridge read type 2 as a warning, so+  `fusion_routing_drc` (and the AI flow's DRC gate) reported the BQ25792 board's 1611 errors as warnings and its+  14 Wire Stub warnings as errors. Each violation now carries `severity` and `approved` from Fusion's own+  constants (read live from the ULP, 2026-10-26).+- **`fusion_export_bom` carries part numbers** (page issue #105): after the old columns come MPN, Manufacturer, LCSC,+  Mouser and DigiKey from each part's attributes, read under every name libraries use (Adom's `MPN`/`LCSC_PN`,+  LCSC/JLCPCB's `LCSC`, SnapEDA's `MANUFACTURER_PART_NUMBER`, `MF`/`MP`...), blank when a part has none. The reply+  counts the parts with an MPN and an LCSC number and names the rest. The export now runs in the exe from the board+  export, in the background, and switches to the board itself when the schematic or 3D view is in front. The same+  names now feed `fusion_board_bom` (which read only `LCSC_PN`) and `fusion_component_data`. Live on BQ25792: 109+  parts, 45 lines, LCSC on 63 parts, MPN on 28.+- **Fixed: a routing read or edit could act on another board than the one named.** `doc.activate()` moves+  Fusion's API to a document without always moving its UI, and the board export and every Electron command act+  on the UI's board. With the two apart, `fusion_routing_state {expectDocument:"A"}` passed its name check and+  returned board B's copper, and `fusion_route_net` drew on B (caught live 2026-10-26, scratch boards only).+  Every routing verb now puts the UI on the named document's tab first (`UI.SwitchToTab`; a tab's index is the+  document's index), and so do the view verbs (`fusion_show_2d_board` and friends reported success while the+  UI stayed put).+- **Saving an electronics design** (page issue #125):+  - `fusion_save_to_cloud` on an electronics design saves the DESIGN (.fprj with its .fsch and .fbrd, linked;+    the 3D PCB beside them when open), whichever of its tabs is in front. A Save As by name with the board in+    front used to write a standalone .fbrd the design never linked.+  - It refuses a design that is already saved (`already_saved_use_save_document`) unless `asCopy:true`, refuses+    a name already in the folder unless `overwrite:true`, creates missing folders on `folderPath`, and needs+    `projectName` when no project is open in Fusion's data panel (Fusion cannot read the active project then).+  - New `fusion_save_document {documentName?, comment?}`: saves the open design in place as a new version and+    reads back each changed document's version before and after and the board the design links.+  - Verified live: first save with the board in front (fprj, fsch, fbrd v1, linked), route a net, save in place+    (board v1 to v2), a second Save As refused; closed and reopened from the cloud, the board shows the routed+    net and the folder holds exactly one .fprj, .fsch and .fbrd.+- **Library 3D models go where the run says** (page issue #126): `fusion_make_3d_package` and+  `fusion_build_library_3d` take `projectName` and `folderPath`; each .f3d is saved into+  `<projectName>/<folderPath or "Adom AI Workspace">/<task>` (folders created), found by name in the hub, never+  the active project. A missing project is refused (`project_not_found`), and a failed save with a named+  destination is reported, not uploaded to the fixed APS folder of another project. The reply's `savedTo` names+  the project and folder. Without `projectName` the mint is unchanged. Verified live: with no project open,+  ADS8588SIPM minted into Default Project/fusion-lane-tests/lib3d/issue-126, nothing new in Main.+- **DisplayLink warning** (page issue #121): when Fusion has detected an indirect display adapter+  (`IndirectDisplayAdapterDetected=1` in its `NMachineSpecificOptions.xml`), Fusion Electronics can die in its+  D3D12 canvas on any monitor. `fusion_readiness` now carries `displayWarning`, and the guided tour and+  `fusion_new_electronics_from_eagle` say so (reply and hint) before they start.+- **The EAGLE import stops on a crash dialog** (page issue #121): `fusion_new_electronics_from_eagle` checks for+  Fusion's D3D12 device-loss and "unexpected condition" dialogs while it waits for each Open dialog, before it+  types a path, while the path is submitted and while the design comes up. It stops at once, cancels its Open+  dialog and answers `fusion_graphics_error` (or `blocked_by_dialog`) with the dialog, instead of sitting at+  `stage: started` for minutes.+- Layer arguments take the standard's names: `F.Cu` / `B.Cu` as well as 1 / 16 (`fusion_route_net`, pours).+- Net names with `!` (active-low, `!CE`) are accepted by the routing verbs; they were refused as invalid.+- Tests: `tests/test_board_model.py` (16 cases over every demo board, against the standard's schemas, copied+  to `contracts/eda-bridge-standard/`), Rust tests for the sheet reader, bodies and aliases.++## 1.11.42 (2026-10-17)++- The "ADOM is driving Fusion" panel no longer sits at 0% (page issue #121). Most steps do not know their own+  percent, and the panel drew that as 0% for the whole step. It now fills by elapsed time against the step's+  usual duration on this machine, counts down the time left, and says "taking longer than usual" past it; a step+  with no estimate shows a moving "Working" bar and a seconds counter. Verified live in Fusion.+- The Dashboard comes back after a container restart (page issue #121). Where systemd runs and sudo needs no+  password, the installer adds `adom-fusion-dashboard.service` (Restart=always, port 8930). The dock button+  reuses that server. Elsewhere it starts from the dock button as before, and the installer says so.+- Release notes for 1.11.10 to 1.11.41 are filled in below.++## 1.11.41 (2026-10-17)++- Guided tour fixes (page issue #121):+  - A beat that fails stops narrating. A beat counts as failed when its action fails, its view cannot be+    confirmed on screen, or its motion never moves the view (after one retry). Before, a beat whose view never+    moved could still be marked `ok`. The caption says the step failed and why, and the tour moves on.+    `viewChanged` now counts any frame after a gesture, not only the last one.+  - Back and Exit are debounced: a repeat within 3 s, or while the same press is queued, is dropped, and so is+    any press for a stopped run.+  - Exit stops the narration, captions and remote at once. The step in progress unwinds at its next Fusion+    call, then cleanup closes the tour's documents.+  - Going back over the chip beat reuses the chip already minted instead of minting a second binding.+  - Once the remote is stopped or hidden, nothing shows it again for that run.+- The floating panel in the electronics editors is parked in the bottom-right corner of Fusion's window, over+  the layer list. Fusion ignores size requests for a floating panel, and its position call fails on a monitor+  left of the primary one, so the bridge moves the window itself. In the 3D view the panel stays docked right.++## 1.11.40 (2026-10-17)++- The optimized GLB's silkscreen is cropped to the board and keyed to clean white on transparent, so it no+  longer lands offset or carries the editor background (page issue #113).+- The bundled fab design rules use neutral names.+- The panel does not appear for a plain view switch (schematic, 2D board, 3D board).+- Board-editor traps added to the fusion-eagle-commands skill.+- Native Rust mechanical checkpoint from a community pull request (#19).+- The exe is signed as "Adom Industries, Inc.".++## 1.11.33 to 1.11.39 (2026-10-06)++- `fusion_remove_pours`: delete pours for a refine, picking far from every pad. Shift-delete takes the whole+  polygon (a plain DELETE took one vertex), verified by count, and the change is undone if a part or track moves.+- EAGLE import: waits up to 90 s for the queued import's Open dialog, never mistakes the schematic's lingering+  dialog for the board's, and restores a minimized Fusion in the background first (minimized, the dialog has no+  controls).+- `fusion_schematic_run`: one `USE` per library (Fusion cannot take a library out of use).++## 1.11.15 to 1.11.32 (2026-10-05)++- Board building from a netlist, end to end (the fusion-board-from-netlist skill): `fusion_board_seed` starts a+  board with the fab's rules and fixed parts, `fusion_schematic_plan` plans a grouped schematic, and+  `fusion_schematic_run` draws it live with complete, non-interactive commands (`ADD` proven against the .lbr so+  the picker never opens, `SET CONFIRM YES` so no prompt is drawn, sizes in mm).+- `fusion_board_source` (the live board as EAGLE XML, read-only), `fusion_board_bom` (MPN, manufacturer, Mouser,+  DigiKey and LCSC from the board's parts, plus the JLCPCB form), `fusion_ripup_nets` (pours stay, and their fill+  is restored and proven), `fusion_change_pours` (pen width and isolation in place, verified).+- `route_net`: the board's clearance rules decide, SMD and through-hole pads and vias are checked as their real+  copper, the via drill is checked only when the path has one, and angled segments land straight.+- EAGLE import types the full path into the Open dialog and is queued so its modal cannot block the call.+- The seat-takeover toast shows at most once per 24 hours.++## 1.11.10 to 1.11.14 (2026-10-04 to 10-05)++- `fusion_capture_library_views` photographs the bound 3D package (footprint and chip, opened by its URN) instead+  of Fusion's Create3DPackage generator, which showed only the footprint and left an unsaved tab (page issue #109).+- A library import interrupted by a restart no longer pins a stale 0% panel over Fusion.+- New verbs for the AI flow's Fusion lane: `fusion_move_parts`, `fusion_place_vias`, `fusion_apply_pours`,+  `fusion_pour_state`; the routing state now lists every part with its position, 3D binding and MPN.+- Contributing guide, demo videos and forum videos in the docs.  ## 1.11.9 (2026-09-29) 

@@ -1,6 +1,6 @@ {   "contract": "fusion-bridge verb catalog",-  "frozen": "2026-10-08",+  "frozen": "2026-10-30",   "note": "The Python bridge and the Rust bridge must both serve this catalog byte-for-byte in meaning: same names, same args, same result shapes, same timeouts. Regenerate ONLY from describe.py and diff in CI.",   "source": "describe.py",   "verbs": [@@ -55,6 +55,98 @@       "summary": "Make a named open document the ACTIVE one before driving it. EDIT and most modelling verbs act on whatever is active, so in a batch with several documents open this is how you stop a verb landing in the wrong file (page issue #47). Prefer passing expectDocument on the verb itself, which fails closed instead of merely re-targeting. An electronics design's schematic, board and 3D view are separate tabs with ONE name (type unknown): the reply says so in sameNameDocuments, and fusion_show_schematic / fusion_show_2d_board / fusion_show_3d_board {documentName} reach a specific view.",       "timeoutSeconds": 60     },+    {+      "example": {+        "dryRun": true,+        "libraryPath": "C:/libs/parts.lbr",+        "models": [+          {+            "name": "SOT-23-5"+          }+        ],+        "symbolName": "LDO"+      },+      "input": {+        "comment": "str",+        "description": "str",+        "dryRun": "bool",+        "libraryPath": ".lbr on the Fusion machine (required)",+        "models": "[{name, pcblib?}] (required)",+        "params": "{key: value}",+        "symbolName": "the component (required)"+      },+      "longRunning": false,+      "name": "fusion_add_models",+      "output": {+        "added": "[str]",+        "alreadyAttached": "[str]",+        "libref": "str",+        "models": "int (footprints on the component now)",+        "params": "int"+      },+      "statusVerb": null,+      "summary": "Attach more footprints to a component (the standard's add_models): each becomes another device of the EAGLE component (Fusion's several-packages-per-component), pins joined by pad number; a model's footprint in another .lbr (pcblib) is copied in first. A footprint already attached is skipped (alreadyAttached), so it is safe to repeat. params, comment and description go on the component. Offline, preflighted.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "gap": 0.3,+        "kind": "clearance",+        "name": "SW",+        "scope1": "InNet('SW1')"+      },+      "input": {+        "drill": "mm (via)",+        "expectDocument": "required: the board's name",+        "gap": "mm (clearance)",+        "kind": "width|clearance|via",+        "min": "mm (width)",+        "name": "required: the class is Adom_<name> for a net scope",+        "remove": "bool: the Adom_<name> class's nets back to the default class, the class zeroed",+        "scope1": "InNet('SW') | InNetClass('pwr') (nets / netClass also work)"+      },+      "longRunning": false,+      "name": "fusion_add_rule",+      "output": {+        "class": "{name, number, widthMm, drillMm, clearances, nets}",+        "command": "str",+        "joined": "[net]",+        "name": "the class",+        "released": "[net] (remove)",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "The standard's add_rule as EAGLE net classes, the board's scoped rules: kind width (min), clearance (gap, to every class and within the class) or via (drill). scope1 InNetClass('X') edits that class; InNet('A') (or nets) puts the nets in a class of their own, Adom_<name>, each joined with one pick on its wire. Read back from the board; every change undone on a mismatch. Length, matched, diffpair and polyconnect rules have no class equivalent and are refused.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "dryRun": true,+        "kicadSym": "C:/staged/AMPLH5030S-150MT.kicad_sym",+        "libraryPath": "C:/libs/parts.lbr",+        "symbolName": "AMPLH5030S-150MT"+      },+      "input": {+        "clear": "bool, default true",+        "dryRun": "bool",+        "kicadSym": ".kicad_sym on the Fusion machine carrying the baked outline (required)",+        "libraryPath": ".lbr on the Fusion machine (required)",+        "symbolName": "the component (required)"+      },+      "longRunning": false,+      "name": "fusion_add_symbol_art",+      "output": {+        "bodyRectMil": "[x1, y1, x2, y2]",+        "component": "str",+        "lines": "int",+        "points": "int",+        "polylines": "int",+        "removed": "int"+      },+      "statusVerb": null,+      "summary": "Draw a chip's outline artwork into a component's symbol (the standard's add_symbol_art), offline in a .lbr: the polylines adom-symbol baked into the KiCad symbol, the KiCad body rectangle mapped onto the EAGLE symbol's own body box, as lines on the symbol layer, so the Fusion symbol shows the same chip as KiCad and Altium. clear (default) removes earlier art first, keeping the body's edges. Preflighted before writing.",+      "timeoutSeconds": 30+    },     {       "example": {},       "input": {},@@ -84,6 +176,56 @@       "summary": "Fusion's OWN alert toasts, read from its log. Fusion draws error/warning toasts in CEF: they are invisible to Win32 enumeration AND to UIA, so a verb can look successful while Fusion is visibly complaining. This reads them, newest last.",       "timeoutSeconds": 30     },+    {+      "example": {+        "mode": "bottom",+        "refs": [+          "C1",+          "C2",+          "C3"+        ]+      },+      "input": {+        "allowOutside": "bool",+        "allowOverlap": "bool",+        "by": "courtyard|anchor, default courtyard",+        "dryRun": "bool",+        "expectDocument": "required",+        "expectedRevision": "optional",+        "gapMm": "distribute spacing (default even between the outer two)",+        "mode": "left|right|top|bottom|centerX|centerY|distributeX|distributeY (required)",+        "refs": "[ref] (two or more, required)",+        "to": "mm: the line (default from the group)"+      },+      "longRunning": false,+      "name": "fusion_align_parts",+      "output": {+        "mismatches": "[{ref, asked, got}]",+        "revision": "str",+        "targets": "[{ref, x, y}]"+      },+      "statusVerb": null,+      "summary": "Line parts up on a common left, right, top, bottom or centre line, or space them evenly (the standard's align_parts), by footprint box (pads, placement and documentation outlines, keepouts) or by anchor point. Rotation and side are kept. A part pushed off the board or onto another part is refused unless allowOutside / allowOverlap. Moved by name and read back.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "dryRun": true+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "the design"+      },+      "longRunning": false,+      "name": "fusion_annotate",+      "output": {+        "planned": "[{sheet, from, to}]",+        "renamed": "[..]"+      },+      "statusVerb": null,+      "summary": "Number every 'R?'-style designator with the lowest free number of its prefix, sheet by sheet, top-left first (the standard's annotate). Fusion names parts as they are added, so there is usually nothing to do.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {},@@ -121,6 +263,42 @@       "summary": "Draw copper pours from a plan: POLYGON per pour (net, layer 1 or 16, outline points, isolate, rank 1..6, width, thermals, orphans), skipping any already on the board with the same net, layer and outline, then RATSNEST fills them. The reply carries Fusion's own fill per pour (filledMm2, islands) and per layer. Removing a pour is not done here.",       "timeoutSeconds": 120     },+    {+      "example": {+        "expectDocument": "fusion-routing",+        "names": [+          {+            "ref": "J1",+            "rotation": 90,+            "size": 1.5,+            "x": 10,+            "y": 20+          }+        ]+      },+      "input": {+        "comments": "[same] for the value text",+        "expectDocument": "required exact board name",+        "expectedRevision": "optional: refuse with stale_board if the board moved on",+        "lines": "[{x1, y1, x2, y2, width? (0.15), side?}]",+        "names": "[{ref, x, y, size?, rotation?, show?}] the designator text's own location (lower left before rotation), mm",+        "remove": "{texts:[raw], lines:[raw]} from fusion_silk_state",+        "texts": "[{text, x, y, size?, rotation?, side?: top|bottom}]"+      },+      "longRunning": false,+      "name": "fusion_apply_silkscreen",+      "output": {+        "after": "silk_state",+        "applied": "int",+        "failed": "int",+        "results": "[ok | err:...]",+        "revision": "str",+        "smashed": "[ref]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Land a silkscreen plan on the live board: designators (names) and values (comments) moved to their own location, sized, turned or hidden; free silkscreen texts and lines added (bottom ones mirrored); earlier free items removed by the raw handle fusion_silk_state gives. Parts not yet smashed are smashed first. Each pick is made with only the target's layer displayed, so a pad or wire is never taken instead, and the board's layer display is restored. Read back; if copper, parts or the outline moved, every command is undone. The edit side of a designator plan (silk_designators).",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {@@ -432,6 +610,27 @@       "summary": "Structured, kit-aware MECHANICAL bill of materials for the active Design assembly (the counterpart to the electronics-only fusion_export_bom). Recurses organizational subassemblies but counts a physical part or a purchased kit/unit ONCE, so hardware modeled inside a kit (a '... with fasteners' bracket, a bearing/pulley) is NOT double-counted the way a flat allOccurrences walk counts it. Matches Fusion's Manage -> BOM quantities. Optionally writes a CSV.",       "timeoutSeconds": 120     },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "lcscMissing": "the BOM lines without an LCSC number (default: read from the board's parts)",+        "panelMm": "[w, h] when it ships in a panel"+      },+      "longRunning": false,+      "name": "fusion_assembly_check",+      "output": {+        "board": "{parts, bottomSideParts, finestPitch, smallestChip, fiducials, ...}",+        "economic": "{ok, rules:[{rule, ok, detail}]}",+        "engine": "str",+        "linesWithoutLcsc": "[...]",+        "service": "economic | standard | null",+        "standard": "{ok, rules}"+      },+      "statusVerb": null,+      "summary": "Ready for JLCPCB assembly (the standard's assembly_check)? The board against both JLCPCB PCBA tiers as published (Economic and Standard): size, thickness and layers, parts on one or both sides, the smallest package and finest pin pitch, fiducials, and the BOM lines with no LCSC number (from the board's own part attributes); answers the cheapest tier every rule allows. The shared checks engine on the live board.",+      "timeoutSeconds": 150+    },     {       "example": {         "filePath": "C:/Users/<user>/adom-lib/ADS8588SIPM.fusion.lbr",@@ -455,6 +654,58 @@       "summary": "LOW-LEVEL primitive: attaches ONE model to ONE package. Prefer fusion_create_library with parts[]. Attach a real 3D chip model to a library package, end to end: opens the .lbr (library active), runs Electron.Create3DPackage to enter the Package3DEnvironment showing the footprint, imports the STEP + auto-orients it flat on the footprint, then executes Package3DStop (FINISH). This BINDS the 3D onto the deviceset (Content Manager shows the 3D nested under the package; the Packages 'Package' column flips Placeholder->part-name). ONE desktop-side step remains: Fusion pops a modal Save dialog (an OWNED popup) - the response _hint gives the exact desktop_ui_click to confirm it. AFTER: re-grab desktop_screenshot_window and check ownedPopupCount for errors; the 3D preview LAGS a beat before showing the real chip. Both paths (filePath/modelPath) are WINDOWS paths - stage from the container first.",       "timeoutSeconds": 240     },+    {+      "example": {+        "powerWidthMm": 0.6+      },+      "input": {+        "apply": "bool, default false",+        "expectDocument": "required: the board's name",+        "powerWidthMm": "default 0.5"+      },+      "longRunning": false,+      "name": "fusion_auto_classes",+      "output": {+        "applied": "bool",+        "applyArgs": "{net_classes, diff_pairs}",+        "engine": "str",+        "proposal": "{classes, pairs, unclassified}",+        "skipped": "[{name, why}]",+        "written": "[{name, success, class}]"+      },+      "statusVerb": null,+      "summary": "Net classes from the nets' own names (the standard's auto_classes), from the shared checks engine: GND, Power (VCC, VDD, 3V3, VBAT...), Clock, HighSpeed (USB, Ethernet, HDMI, PCIe, DDR, MIPI, LVDS, SATA...) and the differential pairs their names spell. A proposal first; apply:true writes the classes that carry a rule (Power's width, powerWidthMm) as Fusion net classes through fusion_add_rule. Fusion pairs nets by their names, so the pairs need no writing.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "nets": [+          "SDA",+          "SCL"+        ]+      },+      "input": {+        "drc": "bool, default true",+        "expectedRevision": "str",+        "lockPreroutes": "bool, default true (Fusion's autorouter always keeps existing tracks)",+        "nets": "[str] (default: every net with unconnected copper)"+      },+      "longRunning": true,+      "name": "fusion_autoroute",+      "output": {+        "added": "{tracks, vias}",+        "after": "{unconnected, errors}",+        "before": "{unconnected, errors}",+        "nets": "[str]",+        "revision": "str",+        "routed": "[str]",+        "success": "bool",+        "unrouted": "[str]"+      },+      "statusVerb": null,+      "summary": "Fusion's autorouter on the given nets, or on every net with unconnected copper. Existing tracks are kept (read back, or the run is undone); Fusion's DRC runs before and after. Refused before anything runs when a copper layer in use is switched off in the board's autorouter setup (Fusion would stop to ask): the reply names the layers.",+      "timeoutSeconds": 600+    },     {       "example": {         "libraryPath": "C:/Temp/PART.lbr",@@ -497,6 +748,33 @@       "summary": "The bill of materials from the live board's own part attributes: one line per MPN with designators, quantity, value, package, manufacturer and the Mouser, DigiKey and LCSC numbers, plus the JLCPCB form (Comment, Designator, Footprint, LCSC). Board-only parts (test pads) are listed as such, and any part missing a distributor number is named. Read-only; with outputDir it also writes bom.csv and bom-jlcpcb.csv there.",       "timeoutSeconds": 60     },+    {+      "example": {+        "dryRun": true,+        "stitching": {+          "net": "GND",+          "pitch": 5+        }+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "required",+        "fiducials": "[{x, y, size?, opening?, side?}]",+        "keepouts": "[{rect, layer?: all|F.Cu|B.Cu}]",+        "mountingHoles": "[{x, y, drill?, plated?, pad?, net?}] or {corners: {inset}, drill?, plated?}",+        "stitching": "{net, pitch?, size?, drill?, clearance?, edge?, region?, max?}"+      },+      "longRunning": false,+      "name": "fusion_board_features",+      "output": {+        "applied": "int",+        "planned": "{mountingHoles, fiducials, keepouts, stitching:{count, points}}",+        "results": "[ok|err: ...]"+      },+      "statusVerb": null,+      "summary": "Board furniture in one call (the standard's board_features): mounting holes (bare, or plated via-holes on a net; at points or the four corners), fiducials (a filled copper circle and its mask opening), keepouts (Fusion's restrict layers) and a stitching-via grid on a net, each spot clear of other copper, pads, holes and the edge. Read back; a mismatch undoes it.",+      "timeoutSeconds": 180+    },     {       "example": {},       "input": {},@@ -509,6 +787,44 @@       "summary": "Raw board geometry XML (copper/arcs/lines) for the open board.",       "timeoutSeconds": 60     },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_board_outline",+      "output": {+        "alreadyThere": "int",+        "drawn": "0",+        "layer": "str",+        "outlineClosed": "bool",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Report the board edge the fab gets. Fusion's edge is its Dimension layer (20) and its Gerbers export it as the outline, so there is nothing to draw: this says how many outline items are there and whether they close. Change the shape with fusion_set_outline.",+      "timeoutSeconds": 60+    },+    {+      "example": {},+      "input": {+        "drc": "bool, default true",+        "expectDocument": "required: the board's name",+        "outputDir": "default %TEMP%/adom-board-report",+        "title": "default the design's name",+        "vendor": "fab record, default jlcpcb"+      },+      "longRunning": false,+      "name": "fusion_board_report",+      "output": {+        "drcStoredInBoard": "bool",+        "engine": "str",+        "path": "the .html",+        "sections": "[...]",+        "sizeBytes": "int"+      },+      "statusVerb": null,+      "summary": "One shareable page for the board (the standard's board_report): every check the shared engine has, run on one bundle of the live board and its companions (stack-up, pours, rules, 3D bodies, a fab record, the schematic's parts and netlist), with Fusion's own DRC and a picture of the board, written as one self-contained HTML file on the Fusion machine. A section missing its input says which. Fusion stores its DRC result in the board (the document then reads as modified): drc:false skips it.",+      "timeoutSeconds": 300+    },     {       "example": {},       "input": {@@ -531,6 +847,27 @@       "summary": "Write the design a new board starts from, as EAGLE source on this machine: the board outline, the fab's design rules (Fusion's own rules block with your clearance, edge distance, minimum width and drill, hole-to-hole, pad and via restring and copper weight; Fusion's defaults are 0.35 mm drill, 1 mm to the edge and a 25 % pad restring, wrong for most fabs), the fixed parts at their places with their nets, and the library they come from. Then fusion_new_electronics_from_eagle imports it as a linked schematic and board.",       "timeoutSeconds": 60     },+    {+      "example": {+        "hMm": 25,+        "wMm": 40+      },+      "input": {+        "expectedRevision": "str",+        "hMm": "float, default 15",+        "wMm": "float, default 15",+        "x0Mm": "float, default 0",+        "y0Mm": "float, default 0"+      },+      "longRunning": false,+      "name": "fusion_board_shape",+      "output": {+        "...": "as fusion_set_outline"+      },+      "statusVerb": null,+      "summary": "A rectangular board outline from its corner and size: fusion_set_outline {outline:{rect:[x0Mm,y0Mm,wMm,hMm]}}.",+      "timeoutSeconds": 180+    },     {       "example": {},       "input": {@@ -565,6 +902,99 @@       "summary": "Read a board's PHYSICAL fabrication stackup (see the pcb-stackup skill): copper layer count + copper/dielectric thicknesses from the EAGLE design rules (layerSetup/mtCopper/mtIsolate) plus the measured FR4 extent. A PCB is Cu/prepreg/Cu/core/.../Cu - the FR4 is NOT one slab. Use to build the stackup table + real-thickness exploded 3D view, and put a stackup table on every exported board's wiki page.",       "timeoutSeconds": 200     },+    {+      "example": {},+      "input": {+        "...": "as fusion_board_info"+      },+      "longRunning": false,+      "name": "fusion_board_summary",+      "output": {+        "...": "as fusion_board_info",+        "aliasOf": "fusion_board_info"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_board_info: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact board name"+      },+      "longRunning": false,+      "name": "fusion_bodies",+      "output": {+        "bodies": "[{ref,side,x0,y0,x1,y1,z0,z1,package,throughHole?,leadsPastFarSideMm?}]",+        "complete": "bool",+        "noBody": "[ref]",+        "returnedTo2d": "bool",+        "revision": "str",+        "surface": "{topZ,bottomZ}",+        "suspect": "[{ref,why:[str]}]",+        "tallest": "{top:{ref,heightMm},bottom}"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Each part's 3D body as a box, from the design's 3D PCB: footprint rectangle in the board frame (x0, y0, x1, y1 mm) and height range above the surface it sits on (z0 standoff, z1 top; below the board for bottom parts). Names the parts with no 3D model (noBody) and the ones whose body is not where the board puts the part (suspect: off its footprint, floating or sunk, from a wrong library model or a 3D PCB not yet updated). The tallest part per side. What a height or enclosure check reads. Switches the design to its 3D PCB and back to the 2D board inside Fusion; takes no window or mouse.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "libraryPath": "C:/libs/buck.lbr",+        "nets": {+          "GND": [+            "R1.2"+          ]+        },+        "outline": {+          "cornerRadius": 1,+          "rect": [+            0,+            0,+            20,+            15+          ]+        },+        "parts": [+          {+            "footprint": "R0603",+            "ref": "R1",+            "rotation": 0,+            "x": 5,+            "y": 5+          }+        ],+        "pcbPath": "C:/Boards/buck.brd"+      },+      "input": {+        "layers": "2|4|6|8",+        "libraryPath": "a .lbr holding every footprint (required)",+        "nets": "{net: ['R1.1', 'U1.3']}",+        "open": "bool, default true",+        "outline": "{rect: [x0, y0, w, h], cornerRadius?} | {points: [[x, y]...]} (default: the parts' box + 2 mm)",+        "parts": "[{ref, footprint, x, y, rotation, comment?}] (required)",+        "pcbPath": "the .brd to write (required)"+      },+      "longRunning": false,+      "name": "fusion_build_board",+      "output": {+        "counts": "{}",+        "documentName": "str",+        "missingParts": "[ref]",+        "padsWired": "int",+        "placed": "int",+        "revision": "str",+        "unconnected": "int - the ratsnest to route",+        "unknownPins": "[]",+        "wrongPins": "[{pin, want, got}]"+      },+      "statusVerb": null,+      "summary": "A NEW board from a parts list and a netlist (the standard's build_board): outline (rect with rounded corners, or points), every footprint from one .lbr placed by its own origin, pad nets assigned, written as EAGLE source (pcbPath overwritten), opened in Fusion as a local design dialog-free, then read back pin by pin. Footprint pad names must match the netlist's pin numbers (R1.1 = pad 1 of R1). Coordinates mm, Y up.",+      "timeoutSeconds": 180+    },     {       "example": {         "lbrPath": "C:/tmp/newlib/AdomBasicParts2.lbr",@@ -579,11 +1009,13 @@       "input": {         "capture": "optional bool (default true)",         "folderId": "optional str",+        "folderPath": "optional str under that project, created if missing (default Adom AI Workspace); the task subfolder goes under it",         "lbrPath": "required str (combined .lbr WINDOWS path to bind + open)",         "openWhenDone": "optional bool (default true)",         "outLbrPath": "optional str (default: overwrite lbrPath)",         "parts": "required [{package, lbrPath (per-part footprint .lbr), modelPath (.step)}]",-        "projectId": "optional str"+        "projectId": "optional str",+        "projectName": "optional str: save the .f3d into this project by name (never the active one; a missing name is refused)"       },       "longRunning": true,       "name": "fusion_build_library_3d",@@ -662,6 +1094,66 @@       "summary": "Change existing pours in place: the pen width (the narrowest copper the fill can reach; a pen wider than a throat leaves it empty) and the isolation. Each pour is named by net, layer and outline, picked on the midpoint of its longest edge, then RATSNEST refills. The readback proves each pour took its new width/isolate and that no track or via changed, and reports the filled area before and after.",       "timeoutSeconds": 120     },+    {+      "example": {+        "mode": "courtyard",+        "thresholdMm": 0.2+      },+      "input": {+        "expectDocument": "required: the board's name",+        "includeSameNet": "bool (pads mode)",+        "maxPairs": "int",+        "mode": "courtyard|pads, default courtyard",+        "refs": "[ref] limit to these parts (default all)",+        "thresholdMm": "report pairs closer than this"+      },+      "longRunning": false,+      "name": "fusion_check_clearance",+      "output": {+        "bodiesUsed": "bool",+        "engine": "str",+        "mode": "str",+        "ok": "bool",+        "pairs": "[{parts, gapMm, at, side|layer}]"+      },+      "statusVerb": null,+      "summary": "Part-to-part clearance (the standard's check_clearance), from the shared checks engine on the live board and fusion_bodies: courtyard mode compares part boxes (pads and 3D bodies) on the same side; pads mode compares pad copper of different parts sharing a copper layer, by its real outline. Pairs closer than thresholdMm, nearest first.",+      "timeoutSeconds": 150+    },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_check_dialogs",+      "output": {+        "count": "int",+        "dialogs": "[{hwnd, title, text, buttons}]",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "List every Fusion dialog open now, each with its title, text and buttons read through UI Automation (no screenshot needed). The bridge expires unknown dialogs by itself before the next add-in verb; in-canvas alerts that have no window are in fusion_alerts.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "minImprovementMm": 0.5+      },+      "input": {+        "expectDocument": "required: the board's name",+        "minImprovementMm": "number",+        "parts": "[ref] (default every 2-pad part)"+      },+      "longRunning": false,+      "name": "fusion_check_orientation",+      "output": {+        "checked": "int",+        "engine": "str",+        "suggestions": "[{ref, from, to, savesMm}]"+      },+      "statusVerb": null,+      "summary": "Advisory (the standard's check_orientation): 2-pad parts whose rotation could be better, each orthogonal turn scored in place by airline length (a routable net's MST with the pad there; a plane-like net's distance to its nearest pad); parts whose best turn saves minImprovementMm are listed. Nothing moves: the shared checks engine on the live board.",+      "timeoutSeconds": 120+    },     {       "example": {         "fileName": "BQ25792",@@ -729,25 +1221,46 @@       "summary": "PRECISELY delete a list of cloud files by lineage urn - SAFE cleanup of AI-created clutter. Deletes ONLY the exact fileIds given (never name-guessing), so it can't touch a teammate's file in a shared folder. Loops server-side. Get the ids from fusion_aps_browse (item .id). Use this to remove f3d files the bridge created. A big list takes minutes (relay may time out at ~60s while deletes continue server-side - re-browse to confirm).",       "timeoutSeconds": 1800     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_clone_symbol",+      "output": {+        "from": "str",+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Copy a component of a .lbr under a new name with copies of its symbols (the standard's clone_symbol).",+      "timeoutSeconds": 30+    },     {       "example": {-        "closeUntitled": true+        "includeScratch": true       },       "input": {-        "closeUntitled": "optional bool default false - also close UNMODIFIED Untitled scratch docs",-        "force": "optional bool default false - with closeUntitled, also discard MODIFIED Untitled docs",-        "save": "optional bool default false"+        "discardUnsaved": "bool, default false: close changed documents without saving (force also works)",+        "includeScratch": "bool, default false: also close never-saved scratch documents (closeUntitled also works)",+        "save": "bool, default false: save each changed document, then close it"       },       "longRunning": false,       "name": "fusion_close_all_documents",       "output": {-        "closed": "[str]",-        "success": "bool",-        "wouldPrompt": "[str]|null"+        "closed": "[name]",+        "keptOpen": "[{name, why}]",+        "remaining": "int",+        "saved": "[name]",+        "success": "bool"       },       "statusVerb": null,-      "summary": "Close ALL open documents without save dialogs. DESTRUCTIVE to unsaved user work - confirm with the human before calling on a box you do not own. By default it SKIPS scratch 'Untitled' docs; pass closeUntitled:true to close the UNMODIFIED ones too (page issue #59: the library/bind flow left ~5 per import, 16 after three, and no caller could clear them), and force:true to also discard MODIFIED Untitled docs, which may hold real unsaved work.",-      "timeoutSeconds": 60+      "summary": "Close every open document without a save dialog; unsaved work is never lost by default (the standard's close_all_documents). A saved document with unsaved changes stays open and is listed in keptOpen, unless save (save it, then close: a new cloud version) or discardUnsaved (close without saving) says otherwise. Never-saved scratch documents close only with includeScratch, and a changed one only with discardUnsaved too. A named, never-saved, changed document is always kept: Fusion would ask where to save it.",+      "timeoutSeconds": 90     },     {       "example": {@@ -755,7 +1268,8 @@       },       "input": {         "name": "optional str (default: active document)",-        "save": "optional bool default false"+        "save": "optional bool default false: save a version, then close",+        "saveToClose": "optional bool: save a version only because the close needs it"       },       "longRunning": false,       "name": "fusion_close_document",@@ -764,7 +1278,7 @@         "success": "bool"       },       "statusVerb": null,-      "summary": "Close ONE document WITHOUT the modal save dialog (save:false discards silently - the automation-safe close). Omit name to close the active document.",+      "summary": "Close ONE document without a modal save dialog. Omit name to close the active document. An unchanged document, or a never-saved scratch one, closes at once. A saved cloud document with unsaved changes is refused (unsaved_cloud_document): Fusion asks to save it even when told not to, so closing it means saving a version, which needs save:true (or saveToClose:true).",       "timeoutSeconds": 60     },     {@@ -785,7 +1299,146 @@     },     {       "example": {-        "folderName": "AI-Scratch",+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "designator": "optional: one part (U1); omit for all",+        "expectDocument": "required exact active board name",+        "limit": "int, default 500"+      },+      "longRunning": false,+      "name": "fusion_component_data",+      "output": {+        "component": "{designator,pattern,comment,library,side,layer,xMm,yMm,rotation,box,wMm,hMm,pads,nets,has3d,locked,partNumber}",+        "components": "[...] (all)",+        "count": "int"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Placement data for one part or every part on the live board, in the background: footprint, value (comment), library, side and copper layer, position and rotation in mm, its extent (box, wMm, hMm: every footprint primitive but text), pad count, the nets on its pads, part number and whether it has a 3D model.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "designator": "required (U1)",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_component_pins",+      "output": {+        "count": "int",+        "designator": "str",+        "pins": "[{ref,name,key,x,y,sizeX,sizeY,rotation,layer,drill,net,shape}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Every pad of one part with its net, position, layer, size, shape and drill (mm), the same rows fusion_routing_state gives, for one part.",+      "timeoutSeconds": 60+    },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "resolutionMm": "raster step, default 0.25"+      },+      "longRunning": false,+      "name": "fusion_copper_balance",+      "output": {+        "engine": "str",+        "layers": "[{layer, percent, ...}]",+        "pairs": "[{layers, percent, differencePoints, ok}]"+      },+      "statusVerb": null,+      "summary": "Copper per layer and how evenly mirrored layers match (bow and twist through reflow), from the board's tracks, pads and Fusion's pour fills: the shared checks engine (adom-eda-checks) on the live board.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_copper_layers",+      "output": {+        "count": "int",+        "layers": "[{name,id,kind,displayed,primitives}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The board's copper layers in stack order (F.Cu, In1.Cu.., B.Cu) with Fusion's layer id, signal or plane, whether displayed, and primitives on each.",+      "timeoutSeconds": 60+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_copy_footprint",+      "output": {+        "from": "str",+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Duplicate a footprint inside a .lbr under a new name (the standard's copy_footprint), offline and preflighted.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "box": [+          20,+          13,+          30,+          16+        ],+        "dryRun": true,+        "expectDocument": "BQ25792",+        "offset": [+          0,+          -10+        ],+        "refMap": {+          "C12": "C13"+        }+      },+      "input": {+        "box": "[x1, y1, x2, y2] mm (required)",+        "dryRun": "bool",+        "expectDocument": "required: the board's name",+        "keepUnmappedNets": "bool, default false",+        "layers": "[layer]",+        "netMap": "{'SIG': 'SIG2'}",+        "offset": "[dx, dy] mm (required)",+        "refMap": "{'U1': 'U5'}",+        "refPattern": "{from: 'CH1_*', to: 'CH2_*'}",+        "validate": "bool, default true"+      },+      "longRunning": false,+      "name": "fusion_copy_routing",+      "output": {+        "clashes": "[{item, at, touches}]",+        "copied": "{tracks, vias}",+        "drc": "{ran, newErrors}",+        "netMap": "{from: to}",+        "pairs": "{ref: ref}",+        "skipped": "[{item, why}]"+      },+      "statusVerb": null,+      "summary": "Copy the tracks and through vias inside a box to an offset (the standard's copy_routing), remapping nets by pairing parts (refMap or refPattern: each source pad's net goes to the partner pad's net), then netMap. A track is copied when both ends are in the box, a via when its centre is. A destination end on another net's copper is refused before anything is drawn (Fusion would ask to join the nets). Read back exactly; with validate (default) Fusion's DRC runs and any new error undoes the copy.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "folderName": "AI-Scratch",         "projectName": "Main"       },       "input": {@@ -807,6 +1460,30 @@       "summary": "Create a subfolder in a cloud project through the signed-in Fusion session's Data API (no APS needed). Idempotent: an existing folder of that name is returned with alreadyExisted:true instead of a duplicate. Folder names are matched case-insensitively. For an APS-side create without Fusion running, use fusion_aps_create_folder.",       "timeoutSeconds": 60     },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "name": "SOT-23",+        "pads": "1,-37,-40,24,28,rect,0;2,37,-40,24,28,rect,0;3,0,40,24,28,rect,0"+      },+      "input": {+        "description": "str",+        "dryRun": "bool",+        "footprints": "[{name, pads, ...}]",+        "libraryPath": "a .lbr on the Fusion machine (required; created if missing)",+        "name": "str (required)",+        "pads": "str or list (required)"+      },+      "longRunning": false,+      "name": "fusion_create_footprint",+      "output": {+        "footprints": "[{footprint, pads}]",+        "libraryState": "opened|created"+      },+      "statusVerb": null,+      "summary": "Create a footprint (an EAGLE package) from a pad list in a .lbr, offline (the standard's create_footprint): pads as 'des,x_mil,y_mil,w_mil,h_mil,rect|round,hole_mil;...' (hole 0 = SMD) or [{number, at, sizeMm, shape, drillMm}], with a documentation outline and >NAME/>VALUE. The library is created when the path does not exist; several at once with footprints. Preflighted before writing.",+      "timeoutSeconds": 30+    },     {       "example": {         "libraryPath": "C:/Temp/PART.lbr",@@ -831,6 +1508,93 @@       "summary": "ONE-CALL library creation for web-control (one call = one consent). EVERY LIBRARY IS MULTI-PART - a single-part library is simply parts:[one entry], and there is no separate single-part verb to choose. Pass parts:[{package, lbrPath, modelPath}] for any number of parts; the older {libraryPath, stepPath} shape still works and is normalised into a one-element parts list, so both run the identical code path and the ETA scales with the part count either way. TWO entry shapes: A) {libraryPath, stepPath} - a ready .lbr plus the 3D; B) {kicadSymbolPath, kicadFootprintPath, stepPath, pinMap?} - KiCad sources; needs adom-lbr, which is Linux-container-only by platform rule, so on Windows/Mac boxes shape B refuses IMMEDIATELY (adom_lbr_unavailable, before any staging or Fusion launch - fusion_readiness reports kicadIngest up front). Convert at AUTHORING time in a container and use shape A. pinMap = explicit {pinName: padName} for when pin numbers do not match pad names (BGA-style). Chains convert -> bind 3D -> prove (four evidence frames + verdict) in the BACKGROUND and returns immediately; poll fusion_prove_result (stage narrates; top-level `verdict` proven/not_proven is the score - `stage:done` only means the chain finished). EVERY PART IS PROVED, not just the first: a 10-component library streams 40 evidence frames, FOUR per component (symbol, footprint, 3d, ganged) in assembly order, each tagged with `part` so a front end can group them as they arrive, and `provedParts[]` reports per-part pass/fail. The library is proven only if EVERY part is - one good part does not vouch for nine unchecked ones. On the FINAL fetch pass {inlineFrames:true} to get each evidence frame as a base64 thumbnailDataUrl a browser can render (plain polls return box paths only). The chain closes its library document on success AND failure - batches need no between-part sweeping. stepPath is required for a PROVEN library - no real 3D body without it.",       "timeoutSeconds": 30     },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "name": "LM358",+        "pins": "1,OUTA,right,100,1;2,-INA,left,100,1;3,+INA,left,200,1;8,V+,left,100,0;4,V-,left,200,0"+      },+      "input": {+        "bodyHeightMil": "default 600",+        "bodyWidthMil": "default 800",+        "description": "str",+        "designator": "default U",+        "dryRun": "bool",+        "libraryPath": "a .lbr on the Fusion machine (required; created if missing)",+        "name": "str (required)",+        "pins": "str (required)",+        "symbols": "[{name, pins, ...}]"+      },+      "longRunning": false,+      "name": "fusion_create_symbol",+      "output": {+        "libraryState": "opened|created",+        "symbols": "[{symbol, pins, parts}]"+      },+      "statusVerb": null,+      "summary": "Create a component in a .lbr, offline (the standard's create_symbol): an EAGLE deviceset with one rectangular symbol per part and its pins on the sides asked ('des,name,left|right|top|bottom,offset_mil[,part[,hiddenNet]];...'); part 0 and hidden-net pins go on a power gate placed on request. Pin numbers are kept so set_params {footprint} can join pins to pads.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "expectDocument": "the design"+      },+      "longRunning": false,+      "name": "fusion_cross_check",+      "output": {+        "boardComponents": "int",+        "matched": "int",+        "onBoardNotOnSheet": "[ref]",+        "onSheetNotOnBoard": "[ref]",+        "schematicComponents": "int"+      },+      "statusVerb": null,+      "summary": "The schematic's designators against the board's (the standard's cross_check): matched, on the sheet only (no board part), on the board only (placed there: logos, holes).",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "the design's name (its schematic or board)",+        "path": "sheet number",+        "ref": "'U1'",+        "refs": "['U1','C3']",+        "select": "bool, default false",+        "symbolId": "'U1:G$1'"+      },+      "longRunning": false,+      "name": "fusion_cross_probe",+      "output": {+        "matches": "[{ref, linked, board:{ref,id,side,x,y,rotation}, schematic:{sheet,id,ref,symbol,value}}]",+        "selected": "[ref]",+        "symbolWithoutPart": "[ref]"+      },+      "statusVerb": null,+      "summary": "From a schematic part to the board part linked to it and back (the standard's cross_probe): Fusion links them by designator. Each match gives the board part (side, x, y, turn, package) and the schematic part (sheet, gate id, symbol, value); linked:false when one side is missing; symbolWithoutPart lists schematic parts with no board part. select:true highlights the matches in both editors.",+      "timeoutSeconds": 90+    },+    {+      "example": {+        "nets": {+          "VBUS": 3+        }+      },+      "input": {+        "expectDocument": "required: the board's name",+        "nets": "{net: amps} (required)",+        "tempRiseC": "default 10"+      },+      "longRunning": false,+      "name": "fusion_current_capacity",+      "output": {+        "engine": "str",+        "nets": "[{net, amps, layers: [{layer, narrowestMm, neededMm, ok}], ok}]"+      },+      "statusVerb": null,+      "summary": "Per net and layer, the narrowest copper against the width a current needs (IPC-2221), and the vias a layer change needs: the shared checks engine on the live board.",+      "timeoutSeconds": 120+    },     {       "example": {         "fileName": "verbtest-scratch",@@ -933,6 +1697,54 @@       "summary": "Detect 2-layer vs 4-layer board (ULP + CAM comparison).",       "timeoutSeconds": 90     },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_diagnostics",+      "output": {+        "addin": "{answering, activeDocument}",+        "bridge": "{version, exe, bundledAddin, cacheDir, stateDir}",+        "env": "{name: value}",+        "installs": "{fusionLauncher}",+        "running": "[{pid, image}]",+        "windows": "{mainTitle, needsSignin, licensingDialog, windows}"+      },+      "statusVerb": null,+      "summary": "Facts for a bug report (the standard's diagnostics), read without driving Fusion: the bridge's version, exe, bundled add-in and folders; the Fusion launcher found; Fusion's processes and windows (sign-in or licensing box up); whether the add-in answers and on which document; and the Adom, Fusion and Autodesk environment variables, with the values of any named like a credential never shown.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_action_ledger"+      },+      "longRunning": false,+      "name": "fusion_dialog_log",+      "output": {+        "...": "as fusion_action_ledger",+        "aliasOf": "fusion_action_ledger"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_action_ledger: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "name": "one pair by its name (omit to list)"+      },+      "longRunning": false,+      "name": "fusion_diff_pairs",+      "output": {+        "count": "int",+        "pairs": "[{name, pos, neg, by}]"+      },+      "statusVerb": null,+      "summary": "The board's differential pairs (the standard's diff_pairs), as Fusion keeps them: by the nets' names, two nets that differ only in a final _P/_N, P/N, +/- or DP/DN. Fusion has no pair object, so pos/neg/remove are refused with how to rename the nets instead.",+      "timeoutSeconds": 60+    },     {       "example": {},       "input": {@@ -949,20 +1761,63 @@       "summary": "Detect + classify (and optionally dismiss) blocking Fusion dialogs. Answers every one with the safe button (No/Cancel via WM_CLOSE, never Yes, never focus-stolen). {categories:[...]} narrows the sweep to those categories (e.g. [\"crash_report\"], the launch janitor's scope).",       "timeoutSeconds": 30     },+    {+      "example": {},+      "input": {+        "...": "as fusion_dismiss_blocking_dialogs"+      },+      "longRunning": false,+      "name": "fusion_dismiss_dialogs",+      "output": {+        "...": "as fusion_dismiss_blocking_dialogs",+        "aliasOf": "fusion_dismiss_blocking_dialogs"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_dismiss_blocking_dialogs: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "dryRun": true,+        "set": {+          "REVISION": "B"+        }+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "the design",+        "set": "{TITLE: ..., REVISION: ...}"+      },+      "longRunning": false,+      "name": "fusion_doc_params",+      "output": {+        "params": "[{name, value}]",+        "set": "int"+      },+      "statusVerb": null,+      "summary": "Read the schematic's global attributes (Fusion's title-block values), or set them with set: {NAME: value} (the standard's doc_params). Read back; a mismatch undoes the edit.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {},       "longRunning": false,       "name": "fusion_document_info",       "output": {-        "isSaved": "bool",+        "data": "the add-in's reply (openDocuments ...)",+        "kind": "project|schematic|board|library|model|other",+        "modified": "bool",         "name": "str",+        "path": "Project/folder/name.ext|null",         "productType": "str",-        "success": "bool"+        "project": "str|null",+        "saved": "bool",+        "success": "bool",+        "version": "int|null"       },       "statusVerb": null,-      "summary": "Metadata for the ACTIVE document: name, product type, save state, version, parent project.",-      "timeoutSeconds": 30+      "summary": "The active document (the standard's document_info): its name, kind (project, schematic, board, library, model), whether it is saved and has unsaved changes, its cloud location, version and project. Read only; opens nothing. The add-in's fields (open documents and the rest) are kept beside them.",+      "timeoutSeconds": 20     },     {       "example": {@@ -985,6 +1840,73 @@       "summary": "The run record of a background fusion_new_electronics_from_eagle import: stage (started | done | failed), documentName, partsExpected (elements in the .brd), partsPlaced (read back from the board), placed[], and the final result. Poll it every few seconds after the import returned its runId.",       "timeoutSeconds": 20     },+    {+      "example": {+        "dryRun": true,+        "libraryPath": "C:/libs/my.lbr",+        "name": "SOIC-8",+        "pads": [+          {+            "number": "1",+            "set": {+              "sizeMm": [+                1.5,+                0.6+              ]+            }+          }+        ]+      },+      "input": {+        "addPads": "[{number, type: smd|thru, at, sizeMm, drillMm?, shape?, layers?, rotation?}]",+        "dryRun": "bool",+        "graphics": "[{layer, mode: append|replace|delete, widthMm?, shapes: [{type: line|arc|rect|circle|poly, ...}]}]",+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "metadata": "{description}",+        "name": "the footprint (required)",+        "pads": "[{number, set?: {sizeMm, at, shape, drillMm, layers, rotation, type, newNumber}, delete?: true}]",+        "renumber": "{map: {'1': 'A1'}} | {sequential: true, start?: 1}"+      },+      "longRunning": false,+      "name": "fusion_edit_footprint",+      "output": {+        "backup": "path",+        "footprint": "as fusion_read_footprint answers it",+        "summary": "{changed, renamed, connectsDropped}"+      },+      "statusVerb": null,+      "summary": "Edit one footprint of a .lbr in place, offline (the standard's edit_footprint): pads changed (size, position, shape, drill, layer, turn, type, number), deleted, added or renumbered (map or sequential), with the devices' connects following a renamed pad and a deleted pad's connects dropped and listed; graphics appended to, replaced on or deleted from a layer (line, arc, rect, circle, poly); the description set. The result must pass the same preflight as fusion_preflight_lbr before it is written; the old file is kept as .bak. 3D models are Fusion cloud links and are refused here.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "edits": [+          {+            "fields": {+              "MPN": "RC0402FR-0710KL"+            },+            "ref": "R5",+            "value": "10k"+          }+        ]+      },+      "input": {+        "dryRun": "bool",+        "edits": "[{ref, value?, newRef?, fields?: {name: value | null}, locked?: bool}] (required)",+        "expectDocument": "required: the board's name",+        "expectedRevision": "optional"+      },+      "longRunning": false,+      "name": "fusion_edit_parts",+      "output": {+        "edited": "[{ref, after: {ref, value, fields, locked}}]",+        "failed": "[{ref, error}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Edit placed parts (the standard's edit_parts): value, designator (newRef), any field (attribute; null removes it) and the lock, each read back. Fusion keeps board and schematic in step, so the edit is in the schematic too. dnp, excludeFromBom, excludeFromPos and mount are refused per part (Fusion keeps them in assembly variants).",+      "timeoutSeconds": 150+    },     {       "example": {         "x1": 0,@@ -1102,6 +2024,33 @@       "summary": "TYPED electronics read model: rows for one of Autodesk's 49 electronics entity classes (Element, Signal, Net, Layer, Via, Smd, Wire, Pad, Part, Instance, Pin, Sheet, Package, Library, Error, Variant...) over the ACTIVE electronics document, with filters, field projection and pagination. Served by Autodesk's own MCP electronics_read when its server answers (fusion_mcp_enable turns it on), else by the board_info geometry export for Board/Element/Library/Package/Layer/Signal/Wire/Error (coordinates in mm). `source` names which. Replaces reading board_info XML by hand.",       "timeoutSeconds": 120     },+    {+      "example": {+        "assembly": true,+        "quantities": [+          5,+          30+        ]+      },+      "input": {+        "assembly": "bool, default false: add an assembly estimate",+        "basicParts": "[ref] parts on the fab's basic list",+        "expectDocument": "required: the board's name",+        "quantities": "[5, 10, 30, 100] (default)"+      },+      "longRunning": false,+      "name": "fusion_estimate_cost",+      "output": {+        "assumptions": "[str]",+        "board": "{sizeMm, layers, thicknessMm, minTrackMm, minGapMm, minDrillMm, holes, smdParts, thtParts, ...}",+        "engine": "str",+        "prices": "[{quantity, board, assembly, total, currency}]",+        "source": "{name, url, read}"+      },+      "statusVerb": null,+      "summary": "The board's numbers a fab quote needs (size, layers, thickness, smallest track, gap and drill, holes, SMD and through-hole parts and joints, unique parts) and a rough price table at the quantities asked, every assumption stated and the price source named with the date it was read: the shared checks engine on the live board.",+      "timeoutSeconds": 150+    },     {       "example": {         "command": "Electron.ImmediateRepaint /full"@@ -1176,16 +2125,17 @@       },       "input": {         "grouped": "optional bool (default true)",-        "outputPath": "optional str"+        "outputPath": "optional str (default %TEMP%/adom-bom.csv)"       },       "longRunning": false,       "name": "fusion_export_bom",       "output": {-        "componentCount": "int",-        "grouped": "bool"+        "csv": "str (the file's text)",+        "data": "{outputPath, componentCount, uniquePartCount, grouped, withMpn, withLcsc, missingMpn, missingLcsc}",+        "output": "str"       },       "statusVerb": null,-      "summary": "Export a Bill of Materials CSV (grouped by value+package) from the open board.",+      "summary": "Export a Bill of Materials CSV from the open board, in the background: Comment, Designator, Footprint, Quantity, Library (grouped by value, footprint, library and MPN) or one line per part, then each part's MPN, Manufacturer, LCSC, Mouser and DigiKey numbers from its attributes (Adom, LCSC/JLCPCB and SnapEDA attribute names all read; blank when a part has none). Switches to the board itself when the schematic or 3D view is in front.",       "timeoutSeconds": 60     },     {@@ -1246,18 +2196,29 @@     },     {       "example": {-        "outputPath": "C:/out/sketch.dxf"+        "expectDocument": "BQ25792",+        "layers": [+          "Edge.Cuts",+          "F.Cu"+        ]       },       "input": {-        "outputPath": "required str"+        "contours": "bool: the outline as closed polylines",+        "expectDocument": "required for the board form: the board's name",+        "layers": "[Edge.Cuts, F.Cu, In1.Cu, B.Cu, F.SilkS, B.SilkS, F.Fab, B.Fab, Dwgs.User or Fusion layer numbers] (the board form)",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-dxf)",+        "outputPath": "the mechanical form's .dxf",+        "units": "mm|in, default mm"       },       "longRunning": true,       "name": "fusion_export_dxf",       "output": {-        "format": "str"+        "empty": "[layer]",+        "files": "[{layer, path, entities}]",+        "units": "str"       },       "statusVerb": null,-      "summary": "Export 2D DXF.",+      "summary": "Board layers to DXF, one file per layer (the standard's export_dxf), when layers is given: the outline (Edge.Cuts: Dimension and Milling), copper (tracks as polylines carrying their width, arcs, vias, pads, Fusion's pour fill), silkscreen and fab (footprint and board lines, circles, rectangles, polygons, texts the readable way up). DXF R12, mm or inches, the board's origin, y up. Without layers it is Fusion's mechanical DXF of the active design (outputPath).",       "timeoutSeconds": 120     },     {@@ -1315,27 +2276,61 @@       "timeoutSeconds": 300     },     {-      "example": {-        "outputDir": "C:/tmp/jlc"-      },+      "example": {},       "input": {-        "outputDir": "optional str (default C:/tmp/adom-gerbers)"+        "expectDocument": "required: the board's name",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-gencad)"       },-      "longRunning": true,-      "name": "fusion_export_gerbers",+      "longRunning": false,+      "name": "fusion_export_gencad",       "output": {-        "fileCount": "int",-        "files": "[{name,size}]",-        "zipPath": "str"+        "components": "int",+        "pads": "int",+        "path": "str",+        "shapes": "int",+        "signals": "int"       },       "statusVerb": null,-      "summary": "Run the bundled JLCPCB CAM job (auto 2/4-layer) to produce the gerber + drill ZIP.",+      "summary": "The board as GenCAD 1.4 (inches, the shared engine's writer) for assembly, test and fixture tools (the standard's export_gencad): outline, pads and padstacks, one shape per footprint with its pins, components (bottom parts mirrored), devices, signals with their nodes, and routes with tracks and vias.",       "timeoutSeconds": 180     },     {-      "example": {-        "outputPath": "C:/out/board.iges"-      },+      "example": {},+      "input": {+        "...": "as fusion_export_gerbers"+      },+      "longRunning": false,+      "name": "fusion_export_gerber",+      "output": {+        "...": "as fusion_export_gerbers",+        "aliasOf": "fusion_export_gerbers"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_export_gerbers: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "outputDir": "C:/tmp/jlc"+      },+      "input": {+        "outputDir": "optional str (default C:/tmp/adom-gerbers)"+      },+      "longRunning": true,+      "name": "fusion_export_gerbers",+      "output": {+        "fileCount": "int",+        "files": "[{name,size}]",+        "zipPath": "str"+      },+      "statusVerb": null,+      "summary": "Run the bundled JLCPCB CAM job (auto 2/4-layer) to produce the gerber + drill ZIP.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "outputPath": "C:/out/board.iges"+      },       "input": {         "outputPath": "required str"       },@@ -1348,6 +2343,48 @@       "summary": "Export to IGES.",       "timeoutSeconds": 300     },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-ipc2581)"+      },+      "longRunning": false,+      "name": "fusion_export_ipc2581",+      "output": {+        "arcs": "int",+        "components": "int (parts with pads)",+        "counts": "{...}",+        "engine": "str",+        "holes": "int",+        "nets": "int",+        "pads": "int",+        "path": "str",+        "pourIslands": "int",+        "traces": "int",+        "vias": "int"+      },+      "statusVerb": null,+      "summary": "The board as IPC-2581 revision C XML (mm), valid against the IPC-2581C schema (the standard's export_ipc2581), written by the shared engine's writer (adom-eda-checks) from Fusion's board model, stack-up and pour fills: layers and stack-up, outline, packages with their pins, components and BOM, nets, and on each copper layer the pads, traces, arcs, vias and the poured copper island by island with its holes, plus the drills. Mode ASSEMBLY: solder mask, paste and silkscreen are not in it (a fab order uses fusion_export_odb).",+      "timeoutSeconds": 180+    },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-ipc356)"+      },+      "longRunning": false,+      "name": "fusion_export_ipc356",+      "output": {+        "nets": "int",+        "path": "str",+        "records": "{throughHole, smd}"+      },+      "statusVerb": null,+      "summary": "The board's IPC-D-356A netlist for bare-board electrical test (the standard's export_ipc356): a 317 record per drilled pad and via, a 327 record per SMD pad, with net, position, size, access side and mask, metric (UNITS CUST 1); net names over 14 characters as NNAME aliases.",+      "timeoutSeconds": 180+    },     {       "example": {         "outputPath": "C:/Temp/TJA1050.scr"@@ -1367,6 +2404,30 @@       "summary": "Export the electronics LIBRARY in front as an EAGLE .scr script via Electron.run EXPORT SCRIPT: a text dump of every symbol, package and device, the round-trip check that a library loaded correctly. Requires an electronics editor to be active (fusion_open_lbr puts the library in front). Returns the path, size and the first 2000 characters as a preview; pull the file to read the rest.",       "timeoutSeconds": 60     },+    {+      "example": {+        "libraryPath": "C:/libs/ADS8588SIPM.fusion.lbr",+        "part": "ADS8588SIPM"+      },+      "input": {+        "footprint": "only this package",+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "outputDir": "default the library's folder",+        "part": "the deviceset's name, or Lib:Name (required)"+      },+      "longRunning": false,+      "name": "fusion_export_library_part",+      "output": {+        "exports": "{symbol, footprint, model, library}",+        "missing": "[model]",+        "models": "[{name, urn, type}]",+        "packages": "[str]",+        "symbols": "[str]"+      },+      "statusVerb": null,+      "summary": "One part of a .lbr into its own small library (the standard's export_library_part): the deviceset with only the symbols its gates use and the packages its devices use (or only one footprint). Offline, no Fusion. A Fusion library holds symbol and footprint together, so both exports name the one file; 3D packages are cloud items, listed by URN.",+      "timeoutSeconds": 30+    },     {       "example": {         "outputPath": "C:/out/part.obj"@@ -1383,6 +2444,28 @@       "summary": "Export to OBJ mesh.",       "timeoutSeconds": 300     },+    {+      "example": {+        "compression": "zip"+      },+      "input": {+        "compression": "zip|tgz|none, default zip",+        "expectDocument": "required: the board's name",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-odb)"+      },+      "longRunning": false,+      "name": "fusion_export_odb",+      "output": {+        "camJob": "str",+        "files": "int",+        "layers": "[str] (the matrix)",+        "nets": "int",+        "path": "str"+      },+      "statusVerb": null,+      "summary": "The board as ODB++ through Fusion's own exporter (the standard's export_odb): copper, mask, paste, silkscreen, dielectrics, drill and rout, the netlist (eda/data) and the components in one tree, packed as asked. Fusion reports an error after writing the tree; the bridge finds the tree by its matrix, checks it and packs it.",+      "timeoutSeconds": 180+    },     {       "example": {         "outputPath": "C:/out/board.glb"@@ -1390,7 +2473,7 @@       "input": {         "async": "bool - RECOMMENDED true: fires the whole export+optimize pipeline in the background and returns {exportId} instantly (the sync form can outlive the relay window on a cold Fusion session); poll fusion_fetch_optimized_glb {exportId}",         "board": "bool default true (export the EAGLE .brd and send it, for the footprint + symbol JSON)",-        "compress": "optional str quantize|draco|none (default: the service default, Draco for molecule boards)",+        "compress": "draco (default) | quantize | none: none gives a plain GLB that wiki README and widget frames can load (they cannot reach a Draco decoder)",         "gerbers": "bool default true (Gerber + Excellon from the bundled CAM job as <stem>-fab.zip; false is recorded in export.json)",         "outputPath": "required str (.glb)",         "pin": "str medium|large default medium (fallback only: the service reads the size from the MP marker names when they carry one)",@@ -1419,6 +2502,27 @@       "summary": "Fusion board -> wiki-grade optimized GLB. Exports STEP, the EAGLE .brd (board:true) and optional silkscreen and submits them to service-step2glb molecule mode (anchor to MP pins + silk bake + gold pins + join/weld/prune + Draco; with the board it also writes <stem>_footprint.json and <stem>_symbol.json beside the GLB, and <stem>.web.glb when the model is over the wiki inline budget). The reply carries the molecule-publish gates (gates.pinSize/pinSizeSource/footprintApplied/footprintPins/footprintRebase/warnings) and its _hint names any gate that is not met. Every export also writes <stem>-fab.zip (Gerber + mixed-plating Excellon + .gbrjob from the bundled JLCPCB CAM job) and export.json (tool and version, exporter version, every source file with sha256 and role including each file in the zip, and the stackup from the Gerber job), per board-look EXPORTERS.md. Nothing in the STEP or the Gerbers is renamed: ~465KB/~31 draw calls vs a raw ~16MB/~25000 that halts the viewer. Bounded-waits `wait`s (default 90); small boards return complete, big boards return {pending, jobId} - finish with fusion_fetch_optimized_glb. Use for a component page's component.parts.model_3d. STACKUP RULE (John 2026-07-15, see pcb-stackup skill): board bbox = the FR4 body, NEVER the whole assembly (components overhang edges + tower above); each overlay goes at ITS layer's z (copper at FR4-top, silk above mask); copper traces are REAL 35um 3D bodies colored like the FR4 - recolor them + translucent mask in the RAW GLB before optimizing to make routing visible; put the measured stackup table on the board's wiki page. PUBLISH EVERYTHING: a board's wiki page repo must carry EVERY exportable design file (.f3d/.step/.usdz/EAGLE .brd+.sch/Fusion .fbrd+.fsch/gerbers/BOM/CPL/GLBs/renders), not just the 3D - the page exists to share the design.",       "timeoutSeconds": 200     },+    {+      "example": {+        "board": true+      },+      "input": {+        "board": "bool",+        "expectDocument": "the design",+        "output": "the .pdf path (default Documents/<design>.pdf)"+      },+      "longRunning": false,+      "name": "fusion_export_pdf",+      "output": {+        "boardPdf": "path|null",+        "outputBytes": "int",+        "pdfPath": "path",+        "sheets": "int"+      },+      "statusVerb": null,+      "summary": "Every sheet of the design as one PDF (the standard's export_pdf), each page Fusion's own render of the sheet; board:true adds the board as a second PDF. Fusion has no assembly or fabrication print outputs.",+      "timeoutSeconds": 180+    },     {       "example": {         "outputPath": "C:/out/part.sat"@@ -1472,6 +2576,26 @@       "summary": "Export the ACTIVE electronics document in Fusion's native source format via Document.CopyToDesktop: .fbrd (board), .fsch (schematic) or .flbr (library); the outputPath extension picks the format. The container holds whichever editor is ACTIVE, so since 1.10.35 the bridge switches to it first: the Schematic Editor for a .fsch, the PCB Editor for a .fbrd (reply carries switchedView). A .flbr still needs the library open (fusion_open_lbr). For plain EAGLE XML use fusion_export_eagle_source.",       "timeoutSeconds": 60     },+    {+      "example": {},+      "input": {+        "expectDocument": "the design",+        "outputPath": "the .net to write (default %TEMP%/adom-spice/<design>.net)"+      },+      "longRunning": false,+      "name": "fusion_export_spice",+      "output": {+        "analyses": "[line]",+        "dialect": "ngspice",+        "elements": "int",+        "includes": "[line]",+        "path": "str",+        "unmapped": "[part]"+      },+      "statusVerb": null,+      "summary": "The design's SPICE netlist (the standard's export_spice): EAGLE's own EXPORT SPICENETLIST of the open design's schematic, written on the Fusion machine with no dialog, in ngspice's dialect. Parts with no SPICE mapping come out as comments (unmapped); analyses and includes (.include/.lib/.model/.subckt) are listed.",+      "timeoutSeconds": 120+    },     {       "example": {         "outputPath": "C:/out/board.step"@@ -1521,6 +2645,29 @@       "summary": "Export to USDZ (AR / Hydrogen 3D).",       "timeoutSeconds": 300     },+    {+      "example": {+        "vendor": "jlcpcb"+      },+      "input": {+        "expectDocument": "required: the board's name",+        "fab": "a record instead",+        "limits": "{minTrack, minClearance, ...} mm",+        "process": "optional record process",+        "vendor": "jlcpcb|pcbway|oshpark ... (adom/pcb-design-rules)"+      },+      "longRunning": false,+      "name": "fusion_fab_check",+      "output": {+        "engine": "str",+        "fab": "the record",+        "measured": "{...}",+        "outsideLimits": "[{limit, boardMm, limitMm, at, source}]"+      },+      "statusVerb": null,+      "summary": "The board's smallest features (track, clearance, drill, annular ring, edge clearance, silk...) compared with a fab's limits: vendor names a record in adom/pcb-design-rules (fetched, the one for the board's copper layer count), or pass fab or limits. Each finding names the fab's page and the date it was read. The shared checks engine on the live board.",+      "timeoutSeconds": 120+    },     {       "example": {         "jobId": "abc123",@@ -1549,6 +2696,196 @@       "summary": "Finish a fusion_export_optimized_glb job: bounded-poll the optimizer by jobId and write the GLB to outputPath when complete. Re-call until status=complete (big boards tessellate a few minutes). No Fusion needed.",       "timeoutSeconds": 150     },+    {+      "example": {+        "count": 3,+        "near": "IC1",+        "sizeMm": [+          2,+          1.25+        ]+      },+      "input": {+        "at": "[x, y] instead of near",+        "check": "bool",+        "clearanceMm": "number",+        "count": "how many spots",+        "edgeMm": "number",+        "expectDocument": "required: the board's name",+        "near": "a designator to search round",+        "part": "the part to place (its size)",+        "side": "top|bottom",+        "sizeMm": "[w, h] instead of part"+      },+      "longRunning": false,+      "name": "fusion_find_space",+      "output": {+        "bodiesUsed": "bool",+        "engine": "str",+        "overlaps": "[...] (check)",+        "spots": "[{x, y, rotation?, distanceMm}]"+      },+      "statusVerb": null,+      "summary": "Free spots on the board for a part (the standard's find_space), from the shared checks engine on the live board and fusion_bodies: near a part (or at a point), for a part or a size, clear of every other part on that side, of that side's tracks and vias, and inside the outline, nearest first; pour hatch does not block a spot. check:true lists parts that already overlap or leave the outline.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "folder": "C:/libs",+        "query": "LM358"+      },+      "input": {+        "folder": "a folder of .lbr files",+        "kind": "symbol|footprint",+        "libraries": "[paths]",+        "query": "str (required)"+      },+      "longRunning": false,+      "name": "fusion_find_symbol",+      "output": {+        "best": "{name, library, exact}",+        "matches": "[{name, library, exact}]"+      },+      "statusVerb": null,+      "summary": "Find components (or footprints with kind:'footprint') by part of their name across .lbr files, offline (the standard's find_symbol): the exact match first, else the shortest name that contains the query. Fusion keeps no installed-library list a script can read, so name the libraries or a folder.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "body": {+          "l": 4.9,+          "w": 3.9+        },+        "dryRun": true,+        "family": "dual",+        "name": "SOIC-8",+        "padLength": 1.55,+        "padWidth": 0.6,+        "pins": 8,+        "pitch": 1.27,+        "span": 5.4+      },+      "input": {+        "ballPad": "bga mm",+        "body": "{w, l, height?, standoff?}",+        "cols": "bga",+        "courtyard": "margin mm, default 0.25",+        "description": "str",+        "dryRun": "bool",+        "exposedPad": "{w, h, x?, y?, number?}",+        "family": "chip | dual | sot | quad | bga",+        "leftPins": "sot",+        "libraryPath": ".lbr on the Fusion machine (required unless dryRun; created if missing)",+        "missing": "bga ['B2']",+        "name": "str (required)",+        "padLength": "mm, along the lead",+        "padShape": "roundrect | rect | round | oval",+        "padWidth": "mm, along the row",+        "pins": "dual/quad total",+        "pinsPerSideX": "quad",+        "pinsPerSideY": "quad",+        "pitch": "mm",+        "polarized": "chip: pin-1 dot",+        "rightPins": "sot",+        "rows": "bga",+        "silkClearance": "default 0.2",+        "silkWidth": "default 0.15",+        "span": "mm, pad centre to pad centre across the rows",+        "spanY": "quad top-bottom"+      },+      "longRunning": false,+      "name": "fusion_footprint_from_land_pattern",+      "output": {+        "courtyardLines": "int",+        "courtyardMm": "[x0, y0, x1, y1]",+        "engine": "str",+        "fabLines": "int",+        "footprint": "str",+        "padTable": "[[name, x, y, w, h]]",+        "pads": "int",+        "silkLines": "int"+      },+      "statusVerb": null,+      "summary": "A complete footprint from the land pattern a datasheet prints (the standard's footprint_from_land_pattern), laid out by the shared engine and written into a .lbr offline: pads numbered the standard way (chip, dual SOIC/TSSOP/DFN, SOT, quad QFP/QFN, BGA), an exposed pad, the courtyard (tKeepout), silkscreen kept 0.2 mm clear of copper with a pin-1 dot (tPlace), a fab outline with a pin-1 chamfer (tDocu). dryRun returns the pad table only. Preflighted before writing.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "designator": "U1"+      },+      "input": {+        "designator": "str (required)",+        "expectDocument": "required: the board's name"+      },+      "longRunning": false,+      "name": "fusion_footprint_primitives",+      "output": {+        "otherPrimitives": "{kind: n}",+        "pattern": "str",+        "primitives": "[{kind, layerId, ...}]",+        "side": "top|bottom"+      },+      "statusVerb": null,+      "summary": "Geometry of one placed part (the standard's footprint_primitives): its pads (with mask and paste), wires and arcs, and texts, placed on the board in mm and mil with layer ids; other kinds are counted.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "reason": "Showing you the routed board you asked to see"+      },+      "input": {+        "reason": "a sentence of 10 characters or more, written for the person at the PC (required)"+      },+      "longRunning": false,+      "name": "fusion_foreground",+      "output": {+        "hwnd": "int",+        "title": "str",+        "windowEtiquette": "str"+      },+      "statusVerb": null,+      "summary": "Bring Fusion in front of the user (the standard's foreground): the one sanctioned exception to running in the background. The user is told why in a notification and given three seconds before the window comes forward.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "dimensionsMm": {+          "A": 1.75,+          "D": 4.9,+          "E": 6.0,+          "E1": 3.9,+          "e": 1.27,+          "pins": 8+        },+        "family": "soic",+        "marking": "LM358",+        "outputPath": "C:/parts/LM358.step"+      },+      "input": {+        "dimensionsMm": "{A, D, E, E1, b, e, L, D2, E2, pins ...}: pins is the total pin count; D2/E2 the exposed pad (missing ones take the family's defaults)",+        "family": "required: chip|soic|qfn|qfp|sot23|dfn|bga|melf|ecap|crystal|header, or any Fusion generator type (dpak, plcc, dip ...)",+        "generator": "engine (default when the engine makes the family) | fusion",+        "marking": "text on the top face",+        "markingStyle": "raised|engraved",+        "outputPath": "the .step to write (on the Fusion machine)"+      },+      "longRunning": false,+      "name": "fusion_generate_body",+      "output": {+        "bboxMm": "{x, y, z}",+        "bodies": "[{x0,y0,x1,y1,z0,z1}]",+        "dimensionsMm": "every dimension used",+        "engine": "str (engine)",+        "family": "str",+        "generator": "engine (absent when Fusion's generator made it: that reply carries manifest)",+        "manifest": "obj (fusion)",+        "marking": "str|null",+        "stepPath": "str"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's generate_body: a part's 3D body from its family and datasheet dimensions (JEDEC letters A, D, E, E1, b, e, L, D2/E2 for an exposed pad, plus pins, the total pin count), optionally marked on top, written as a STEP on the Fusion machine. The shared writer (adom-eda-checks) makes chip, soic, qfn, qfp, sot23, dfn, bga, melf, ecap, crystal and header without Fusion; any other family, or generator:fusion, goes to Fusion's own package generator (fusion_generate_package: about 50 families, markings etched as real text), which gets pins converted to its own count.",+      "timeoutSeconds": 120+    },     {       "example": {         "etch": "103",@@ -1640,6 +2977,59 @@       "summary": "Read current Fusion appearance/navigation preferences (theme, activeTheme, invertScrollZoom, orbitScheme, modelingOrientation, gestureNav, cameraPivot, lengthUnit) as friendly values - the same keys fusion_set_preference accepts.",       "timeoutSeconds": 20     },+    {+      "example": {+        "maxTopMm": 8,+        "minGapMm": 0.25+      },+      "input": {+        "expectDocument": "required: the board's name",+        "limit": "tallest parts listed, default 25",+        "maxBottomMm": "below the bottom side",+        "maxTopMm": "height limit above the top side",+        "minGapMm": "default 0: collisions only",+        "regions": "[{rect:[x1,y1,x2,y2], maxMm, side?, name?}] lid features"+      },+      "longRunning": false,+      "name": "fusion_height_check",+      "output": {+        "collisions": "[...]",+        "complete": "bool",+        "engine": "str",+        "heights": "[{ref, side, heightMm, rect}]",+        "noBody": "[ref]",+        "ok": "bool",+        "overLimit": "[...]",+        "regionHits": "[...]",+        "tallest": "{top, bottom}",+        "tooClose": "[...]"+      },+      "statusVerb": null,+      "summary": "Will it fit the enclosure (the standard's height_check)? Each part's height from its 3D body (fusion_bodies), the parts over a top or bottom limit or under a lid region, and bodies that collide or come closer than minGapMm: the shared checks engine. Parts without a body are listed in noBody and the answer is complete:false, never a pass for them.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "z0": 50+      },+      "input": {+        "apply": "{scope}",+        "diff": "ohms, differential",+        "expectDocument": "required: the board's name",+        "gapMm": "pair gap",+        "z0": "ohms, single-ended"+      },+      "longRunning": false,+      "name": "fusion_impedance",+      "output": {+        "apply": "plan",+        "engine": "str",+        "layers": "[{layer, model, widthMm, ...}]"+      },+      "statusVerb": null,+      "summary": "The track width (and pair gap) for a target impedance on each copper layer, from the board's stack-up: the shared checks engine. apply:{scope} answers fusion_add_rule arguments (a plan; nothing changes).",+      "timeoutSeconds": 120+    },     {       "example": {         "filePath": "C:/Temp/TJA1050.fbrd"@@ -1664,6 +3054,40 @@       "summary": "Import a Fusion-NATIVE electronics file (.fsch schematic, .fbrd board, .flbr library; NOT legacy EAGLE .sch/.brd/.lbr) from the Fusion machine as a NEW local document via Document.newDesignFromLocal. The document is unsaved: fusion_save_to_cloud persists it, fusion_close_document discards it. The bridge captures a post-open screenshot because Fusion can raise a blocking dialog the API cannot see.",       "timeoutSeconds": 60     },+    {+      "example": {+        "dryRun": true,+        "footprintSpec": "C:/specs/fp.spec",+        "libraryPath": "C:/libs/parts.lbr",+        "params": {+          "MPN": "TPS7A2033"+        },+        "symbolSpec": "C:/specs/sym.spec"+      },+      "input": {+        "comment": "str",+        "description": "str",+        "dryRun": "bool",+        "footprint": "an existing footprint for the symbol when no footprintSpec",+        "footprintSpec": "path or text: META|name|desc PAD|des|x|y|w|h|shape|hole|layer|crpct LINE ARC DISC (mm)",+        "libraryPath": ".lbr on the Fusion machine (pcbLib/schLib accepted: one Fusion library holds both)",+        "mode": "symbol display mode, default 0",+        "params": "{MPN: ...}",+        "step": ".step path (needs a symbol; signed-in Fusion)",+        "symbolSpec": "path or text: META|libref|desc|designator MODE RECT PIN|mode|number|name|x|y|orient|len|hide|etype LINE ARC (mils; x,y the pin's body end)"+      },+      "longRunning": false,+      "name": "fusion_import_part",+      "output": {+        "backup": "path",+        "footprint": "str",+        "steps": "[{build_footprint, padAliases, replaced}, {build_symbol, modesInSpec}, {add_models}, {params}, {add_body, wipUrn}]",+        "symbol": "str"+      },+      "statusVerb": null,+      "summary": "One call imports a whole part (the standard's import_part): the footprint spec and the symbol spec (the same files Altium's bridge takes) become a footprint, a symbol and a component in one .lbr, every pin joined to its pad by number (a repeated pad number becomes N@2... on the same pin), params and comment as attributes, preflighted before writing; a STEP is then minted and bound to the component, dialog-free. Importing again REPLACES the footprint, the symbol and the 3D body. An EAGLE symbol has one look: the spec's mode (default 0) is drawn.",+      "timeoutSeconds": 600+    },     {       "example": {         "filePath": "C:/Temp/part.step"@@ -1681,6 +3105,44 @@       "summary": "Import a STEP/.stp (or other native-importable) file into a NEW Fusion design via the native import API. The open-electronics hints redirect .step here. (Was implemented but missing from this catalog until the verb suite's reverse-drift check caught it, 2026-08-14.)",       "timeoutSeconds": 300     },+    {+      "example": {+        "at": [+          5,+          20+        ],+        "dryRun": true,+        "layer": "F.SilkS",+        "svgPath": "C:/art/logo.svg",+        "widthMm": 8+      },+      "input": {+        "anchor": "topleft|center",+        "at": "[x, y] mm (required)",+        "dryRun": "bool",+        "expectDocument": "required: the board's name",+        "layer": "default F.SilkS (B.SilkS, F.Mask, B.Mask, F.Paste, B.Paste, or a non-copper Fusion layer)",+        "mirror": "default true on bottom layers",+        "scale": "default 1 (the SVG's own size)",+        "svg": "the SVG text instead",+        "svgPath": "an .svg on the Fusion machine",+        "toleranceMm": "row height and curve tolerance, default 0.02",+        "widthMm": "the artwork's width"+      },+      "longRunning": false,+      "name": "fusion_import_svg",+      "output": {+        "boxMm": "[x1, y1, x2, y2]",+        "ids": "[id]",+        "rects": "int",+        "shapes": "int",+        "sizeMm": "[w, h]",+        "skipped": "[{element, why}]"+      },+      "statusVerb": null,+      "summary": "Import SVG artwork (a logo, a label) onto the board (the standard's import_svg): paths, rects, circles, ellipses and polygons with their transforms; curves and arcs flattened to toleranceMm; a shape inside another is a hole. Fusion's POLYGON asks for a signal name in a dialog, so the artwork is drawn as rectangles row by row (toleranceMm rows, repeated rows merged). Bottom layers are mirrored so it reads from the back. Read back; if anything else changed, every rectangle is undone. Copper layers are refused: Fusion draws copper shapes as signal pours and asks for the name in a dialog.",+      "timeoutSeconds": 120+    },     {       "example": {         "worldSpace": true@@ -1702,6 +3164,21 @@       "summary": "GEOMETRY READ-BACK: what actually got built, in MILLIMETRES. Per body: bbox, sizeMm, volumeMm3, areaMm2, faceCount, cylindricalFaceCount, appearance, material, isVisible. Use this to VERIFY your own modelling - a body at the wrong Z (a double-applied offset, a part buried inside another) renders perfectly and is INVISIBLE in a screenshot, and this work is often matte-black parts on a dark canvas where pixels are a weak check. cylindricalFaceCount is the cheap way to confirm holes were actually cut: a symmetric cut that reaches nothing fails SILENTLY with no exception. Pass worldSpace:true to resolve bodies through their occurrence transforms (assembly placement); optionally filter with occurrence. Fusion's API is centimetres - this converts for you.",       "timeoutSeconds": 130     },+    {+      "example": {},+      "input": {+        "...": "as fusion_install_fusion"+      },+      "longRunning": false,+      "name": "fusion_install",+      "output": {+        "...": "as fusion_install_fusion",+        "aliasOf": "fusion_install_fusion"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_install_fusion: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {},@@ -1746,6 +3223,19 @@       "summary": "COMPOSITE, the Fusion twin of kicad_install_library_bundle (#68): ONE call takes a staged Cloud Library bundle (zip of <Lib>.lbr + <Part>.step models, or a bare lbrPath with STEPs beside it), unpacks it safely, places it under ~/Documents/Adom Libraries/<name>/, pairs EVERY deviceset with its STEP by name (deviceset, package, normalised, prefix; a one-part library pairs its single model regardless), lints part numbers (partMetadata: MPN, manufacturer, Mouser/DigiKey/LCSC - reported, never blocking), pre-flights Fusion state (fusion{status}), and starts the same bind -> prove chain fusion_create_library runs. ASYNC BY CONTRACT: returns IMMEDIATELY with runId + statusVerb because a STEP bind is 3-15 minutes and cannot fit a relay window; poll fusion_prove_result (measured percent, four streamed proof frames per part, provedParts[], and an addin_restart_required payload the CALLER turns into the ask). PARTIAL SHIPS: a deviceset with no model is a NAMED skip in unbound[], the rest still bind; partsBound < partsTotal is the signal. Each part is minted on its own single-deviceset library (the Package3D generator loads the FIRST package of the open library, so a merged library would put every chip on part one's footprint), with the STEP placed exactly as published (orient:false, origin trusted), then all urns are bound into the merged library, and after prove the bound library is SAVED TO THE CLOUD under <project>/Adom Libraries so it appears in Fusion's Library Manager (cloudLibrary{saved, fileId, duplicatesBefore} in fusion_prove_result). Per-part scaffolding is deleted; the user is left with one library plus its per-package f3d folder. capture:false only places the files and returns. This is the one contract the wiki CLI (`library install --format fusion`) and the Export button both read; the recipe has one owner.",       "timeoutSeconds": 60     },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_instances",+      "output": {+        "count": "int",+        "instances": "[{pid, image, parentPid}]"+      },+      "statusVerb": null,+      "summary": "Every running Fusion (the standard's instances): pid, image and parent of each Fusion process. Fusion runs one instance per user, so verbs drive the one running.",+      "timeoutSeconds": 10+    },     {       "example": {},       "input": {@@ -1767,17 +3257,137 @@     {       "example": {},       "input": {-        "skipCleanClose": "optional bool"+        "expectDocument": "required: the board's name",+        "outputDir": "the order folder (default %TEMP%/JLCPCB order <board>; emptied first)"       },       "longRunning": false,-      "name": "fusion_kill",+      "name": "fusion_jlcpcb_order",       "output": {-        "output": "str",-        "success": "bool"+        "assemblyService": "economic | standard | null",+        "bomFiles": "[path] incl. bom-jlcpcb.csv, cpl-jlcpcb.csv",+        "folder": "path",+        "gerberZip": "{path, files}",+        "issues": "[{from, what, at?}]",+        "orderForm": "{layers, dimensionsMm, outerCopperOz, minTrackSpaceMm, minHoleMm}",+        "ready": "bool: fab fits, an assembly tier passes, no issues"       },       "statusVerb": null,-      "summary": "Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged process). Closes docs cleanly first when reachable.",-      "timeoutSeconds": 30+      "summary": "A JLCPCB order in one call (the standard's jlcpcb_order): the board against JLCPCB's fab limits (adom/pcb-design-rules), the Gerbers and drill zipped by the bundled JLCPCB CAM job, the JLCPCB BOM and pick-and-place (CPL), the assembly-tier check and the order-form values (layers, size, outer copper, smallest track/space and hole), in one folder written fresh, with every issue in one list. Fusion has no Silkscreen Preparation: silk goes out as drawn.",+      "timeoutSeconds": 300+    },+    {+      "example": {},+      "input": {+        "skipCleanClose": "optional bool"+      },+      "longRunning": false,+      "name": "fusion_kill",+      "output": {+        "output": "str",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged process). Closes docs cleanly first when reachable.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_start"+      },+      "longRunning": false,+      "name": "fusion_launch",+      "output": {+        "...": "as fusion_start",+        "aliasOf": "fusion_start"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_start: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_layer_stack",+      "output": {+        "copperLayers": "int",+        "layers": "[{name,layerId,kind:signal|plane,copperUm,dielectricUm?,dk1000?,dielectric:[{kind,um,dk,material}],mid?}]",+        "notes": "[str]",+        "revision": "str",+        "source": "str",+        "totalUm": "num"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The board's stack-up in the background, from Fusion's own Layer Stack Manager data in the board: copper layers top to bottom (F.Cu, In1.Cu, ..., B.Cu) with copper thickness in micrometres, the dielectric below each (thickness, Dk x 1000, prepreg or core, material) and the total board thickness. What impedance, current-capacity and copper-balance checks read. A board with no Layer Stack Manager data falls back to its design rules and says the dielectric constant is unknown. No view switching (fusion_board_stackup is the older 2D/3D read).",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_layers",+      "output": {+        "count": "int",+        "layers": "[{id,name,fusionName,kind,displayed,primitives}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The board's layer set: id, name (copper by the standard's names, the rest by Fusion's own: SilkscreenTop, BoardOutline...), kind (copper, silkscreen, mask, paste, outline, drill, keepout, documentation), whether it is displayed, and how many primitives it carries.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_layers_in_use",+      "output": {+        "copperLayersInUse": "[{layerId,name,primitives}]",+        "layersWithPrimitives": "[{layerId,name,primitives}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Which layers actually carry something: copper layers with copper (most first) and every layer with any primitive (board, footprints on their real side, signals; a via counts on each layer it passes).",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "matchTo": "D_N",+        "net": "D_P"+      },+      "input": {+        "expectDocument": "required: the board's name",+        "matchTo": "a net whose length to match instead",+        "maxAmplitudeMm": "number",+        "net": "the net (required)",+        "pitchMm": "number",+        "targetMm": "the length to reach"+      },+      "longRunning": false,+      "name": "fusion_length_tune",+      "output": {+        "addedMm": "number",+        "engine": "str",+        "remove": "fusion_remove_items arguments",+        "revision": "str",+        "routeNet": "fusion_route_net arguments"+      },+      "statusVerb": null,+      "summary": "Plan the lengthening of a routed net (the standard's length_tune), from the shared checks engine: a serpentine in its longest straight track with room beside it, sized to add exactly what targetMm (or matching matchTo) needs, clear of other copper by the board's rule. Answers remove (that one track, fusion_remove_items arguments) and the routeNet that replaces it (fusion_route_net arguments).",+      "timeoutSeconds": 120     },     {       "example": {@@ -1819,6 +3429,67 @@       "summary": "Every ORDERABLE variant in a .lbr with its part numbers - offline, no Fusion needed. For an EE this is the point of the library: two variants can share ONE symbol, ONE footprint and ONE 3D body and still be different products (an AEC-Q100 automotive part vs the baseline one), and that difference lives ENTIRELY in the metadata. EAGLE spells the orderable identity as deviceset + device + technology: <device> carries the PACKAGE variant, <technology> carries the GRADE/temperature variant, and attributes hang off <technology>. Reports per-variant MPN / MANUFACTURER / MOUSER_PN / DIGIKEY_PN / LCSC_PN (the exact names this bridge's own BOM export reads), plus warnings when variants are indistinguishable, share an MPN, or a deviceset has no description. These warnings never block the library from opening - they say whether an EE could actually order from it.",       "timeoutSeconds": 15     },+    {+      "example": {+        "libraryPath": "C:/libs/power.lbr",+        "parts": [+          "TPS54202"+        ]+      },+      "input": {+        "libraryPath": "the .lbr on the Fusion machine",+        "parts": "[device set name]",+        "views": "[symbol, footprint, 3d, device] (default all)"+      },+      "longRunning": true,+      "name": "fusion_library_views",+      "output": {+        "aliasOf": "fusion_capture_library_views",+        "captured": "[{package, view, path, ok}]"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's library_views, served by fusion_capture_library_views: pictures of library parts (symbol, footprint, 3D body on the footprint, and the device view mapping pins to pads), each an image file.",+      "timeoutSeconds": 600+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_account"+      },+      "longRunning": false,+      "name": "fusion_license_status",+      "output": {+        "...": "as fusion_account",+        "aliasOf": "fusion_account"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_account: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "libraryPath": "C:/libs/parts.lbr"+      },+      "input": {+        "libraryPath": ".lbr on the Fusion machine (required)",+        "names": "[footprint or component names] (default all)"+      },+      "longRunning": false,+      "name": "fusion_lint_library",+      "output": {+        "checked": "int",+        "engine": "str",+        "errors": "int",+        "findings": "[{name, kind, rule, severity, detail}]",+        "infos": "int",+        "ok": "bool",+        "unread": "[]",+        "warnings": "int"+      },+      "statusVerb": null,+      "summary": "Is this library fit to ship (the standard's lint_library)? A .lbr read offline and judged by the shared checks engine: each footprint's pads (none, zero-size, unnumbered, duplicate numbers), courtyard (tKeepout), silkscreen, 3D package and description, and each component's pins against its footprint's pads, its linked footprint and its MPN. Every problem is a finding with a rule name and a severity.",+      "timeoutSeconds": 30+    },     {       "example": {         "projectName": "Main"@@ -1850,6 +3521,78 @@       "summary": "List the cloud PROJECTS visible to the signed-in Fusion session (hub walk - slow on big teams; prefer fusion_aps_search for finding files).",       "timeoutSeconds": 120     },+    {+      "example": {},+      "input": {+        "...": "as fusion_list_text_commands"+      },+      "longRunning": false,+      "name": "fusion_list_commands",+      "output": {+        "...": "as fusion_list_text_commands",+        "aliasOf": "fusion_list_text_commands"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_list_text_commands: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_list_designators",+      "output": {+        "count": "int",+        "designators": "[str]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Every part designator on the live board, in natural order (C2 before C11).",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "projectName": "Default Project"+      },+      "input": {+        "budgetSeconds": "default 150",+        "depth": "folder depth, default 3",+        "projectName": "one project to walk (default: every project)"+      },+      "longRunning": false,+      "name": "fusion_list_installed_libraries",+      "output": {+        "complete": "bool",+        "count": "int",+        "foldersWalked": "int",+        "libraries": "[{name, project, folder, version, id, modified}]"+      },+      "statusVerb": null,+      "summary": "The libraries Fusion offers to place from (the standard's list_installed_libraries): the hub's electronics libraries (.flbr files), which Library Manager's Hub Libraries tab shows and fusion_install_library_bundle saves to. Fusion keeps no local list and draws that tab without UI Automation, so this walks the hub's projects and folders through the signed-in session, breadth first to a depth and within a time budget; complete:false when cut short.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_list_nets",+      "output": {+        "count": "int",+        "nets": "[{name,pads,tracks,arcs,vias,pours,class}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Every net on the live board with its pad, track, arc, via and pour counts and its net class.",+      "timeoutSeconds": 60+    },     {       "example": {         "filter": "Electron"@@ -1901,11 +3644,13 @@         "captureLabel": "optional str (capture before/after)",         "fileName": "optional str",         "folderId": "optional str (default upload folder)",+        "folderPath": "optional str under that project, created if missing (default Adom AI Workspace); the task subfolder goes under it",         "lbrPath": "required str (.lbr WINDOWS path; its FIRST package's footprint is loaded)",         "modelPath": "required str (.step WINDOWS path)",         "orient": "optional bool (default true). false = import exactly as authored: NO bounding-box reorientation and NO pin-1 rotation (1.10.8)",         "placement": "optional {translation:[x,y,z] mm, rotation:[rx,ry,rz] deg (about X, then Y, then Z, extrinsic, about the origin), scale:1} from the manufacturer's authored transform. Bypasses every heuristic; the reply returns the applied 4x4 matrix (mm), verification (verified|mismatch), source {path, sha256, bytes} and warnings. Non-finite values, wrong shapes and any scale other than 1 are refused before Fusion is touched (invalid_placement / unsupported_scale)",-        "projectId": "optional str (default MAIN-project)"+        "projectId": "optional str (default MAIN-project)",+        "projectName": "optional str: save the .f3d into this project by name (never the active one; a missing name is refused)"       },       "longRunning": true,       "name": "fusion_make_3d_package",@@ -2138,6 +3883,15424 @@       "summary": "Full tool list from Autodesk's Fusion MCP server INCLUDING input schemas, so you can construct a valid fusion_mcp_call. These are Autodesk's tools, not this bridge's.",       "timeoutSeconds": 45     },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_mech_capabilities",+      "output": {+        "idempotency": "object",+        "operations": {+          "assembly_properties": {+            "description": "High-accuracy physical properties of whole root assembly (default) or an exact Component/Occurrence/BRepBody. Returns mass kg, volume mm3, area mm2, center of mass mm, mean density kg/mm3 and definition/instance coordinate scope.",+            "properties": {+              "entity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "bom": {+            "description": "Structured component-definition and instance BOM; quantities by actual identity, root bodies plus nested children; purchased metadata collapses subtrees unless exploded. Physical mass includes all unsuppressed bodies exactly once per instance. Includes exact current active configuration provenance; incomplete configuration scope refuses. Visibility does not remove quantity. Returns the indented structure with item numbers, the flat purchasing list (make/buy, category, cost, mass), the extrusion cut list (and a bar plan with stockLengthMm), the fastener rollup, totals with cost coverage, and warnings for missing data.",+            "properties": {+              "budgetSeconds": {+                "description": "Stop the cloud reads of part numbers and descriptions (about 0.5 s each on a cloud assembly) once the call has run this long (default 40); the rest come back as nativePending, and the next run continues from what this one read.",+                "maximum": 3600,+                "minimum": 5,+                "type": "number"+              },+              "currency": {+                "description": "ISO 4217 code (USD, EUR) for lines with a unit cost and none of their own; default USD.",+                "type": "string"+              },+              "explodePurchased": {+                "type": "boolean"+              },+              "includeLibraries": {+                "description": "Count body-less groups named as a library (\"Vendor library\", a palette of parts kept to copy from). Default false: they are listed in excluded with reason library_group.",+                "type": "boolean"+              },+              "inferKits": {+                "description": "Count an assembly as one bought line when its name reads as a bought product (an imported .stp/STEP translator model, a McMaster number, a vendor note such as \"(vendor STEP)\" or \"(modelled)\", a maker's name) or its children are a circuit board's footprints. Default true. An explicit asPurchased or makeBuy wins, and so does a name that says it is made here (fabricated, 3D printed, machined).",+                "type": "boolean"+              },+              "kerfMm": {+                "description": "Saw kerf per cut in the bar plan; default 3.",+                "maximum": 50,+                "minimum": 0,+                "type": "number"+              },+              "nativeProperties": {+                "description": "Read part numbers and descriptions (default true; cached per component revision). false gives the structure, quantities and metadata attributes in seconds on a big cloud assembly.",+                "type": "boolean"+              },+              "physicalTotals": {+                "description": "Sum mass and volume over every body instance (default true). false skips that walk on a big assembly; per-line unit mass is still read.",+                "type": "boolean"+              },+              "stockLengthMm": {+                "description": "Stock bar length for the cut list's bar plan (first-fit decreasing).",+                "exclusiveMinimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "bom_export": {+            "description": "Export flat grouped purchasing rows or structured parent/path/depth instance rows and supplier provenance to CSV with exclusive/atomic publication. This external effect is separate from model transactions. Both CSV modes include document/revision and current active configuration table/row provenance.",+            "properties": {+              "budgetSeconds": {+                "description": "As for bom (default 40): rows of components whose part number was left for later have it blank, and the response's nativePending counts them; export again to fill them in.",+                "maximum": 3600,+                "minimum": 5,+                "type": "number"+              },+              "currency": {+                "description": "ISO 4217 code (USD, EUR) for lines with a unit cost and none of their own; default USD.",+                "type": "string"+              },+              "explodePurchased": {+                "type": "boolean"+              },+              "filename": {+                "type": "string"+              },+              "includeLibraries": {+                "description": "Count body-less groups named as a library (\"Vendor library\", a palette of parts kept to copy from). Default false: they are listed in excluded with reason library_group.",+                "type": "boolean"+              },+              "inferKits": {+                "description": "Count an assembly as one bought line when its name reads as a bought product (an imported .stp/STEP translator model, a McMaster number, a vendor note such as \"(vendor STEP)\" or \"(modelled)\", a maker's name) or its children are a circuit board's footprints. Default true. An explicit asPurchased or makeBuy wins, and so does a name that says it is made here (fabricated, 3D printed, machined).",+                "type": "boolean"+              },+              "kerfMm": {+                "description": "Saw kerf per cut in the bar plan; default 3.",+                "maximum": 50,+                "minimum": 0,+                "type": "number"+              },+              "mode": {+                "description": "flat: the purchasing list with make/buy and its reason; structured: one row per instance; indented: item numbers and quantity per parent; cutlist: extrusions by profile and length; fasteners: hardware by part number; wires: each cut wire with gauge, color and length; order: bought lines merged by supplier part number.",+                "enum": [+                  "flat",+                  "structured",+                  "indented",+                  "cutlist",+                  "fasteners",+                  "wires",+                  "order"+                ]+              },+              "nativeProperties": {+                "description": "Read part numbers and descriptions (default true; cached per component revision). false gives the structure, quantities and metadata attributes in seconds on a big cloud assembly.",+                "type": "boolean"+              },+              "overwrite": {+                "type": "boolean"+              },+              "physicalTotals": {+                "description": "Sum mass and volume over every body instance (default true). false skips that walk on a big assembly; per-line unit mass is still read.",+                "type": "boolean"+              },+              "stockLengthMm": {+                "description": "Stock bar length for the cut list's bar plan (first-fit decreasing).",+                "exclusiveMinimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename"+            ],+            "type": "object"+          },+          "cad_import": {+            "description": "Import a pre-downloaded local STEP/SAT into a new wrapper component in Hybrid design. Validate optional expected SHA-256, record actual source/hash/supplier metadata, preserve camera, measure model recovery. Does not fetch URLs or create cloud documents. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "asPurchased": {+                "type": "boolean"+              },+              "filename": {+                "type": "string"+              },+              "name": {+                "type": "string"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "provenance": {+                "additionalProperties": false,+                "properties": {+                  "description": {+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  }+                },+                "required": [+                  "supplier",+                  "supplierPartNumber",+                  "sourceUrl"+                ],+                "type": "object"+              },+              "sha256": {+                "type": "string"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename",+              "provenance"+            ],+            "type": "object"+          },+          "cam_inspect": {+            "description": "Read the active document's CAM: setups, their operations' toolpath state, warnings and errors, and NC programs.",+            "properties": {},+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "cam_job": {+            "description": "Make a milling job: a setup on the given bodies, then operations in order (strategy face, adaptive, contour, parallel, scallop, pocket_clearing or drill), each with a tool from Fusion's sample library chosen by type and diameter (nearest) and optional Fusion parameter overrides by name. Drill picks the bodies' holes of the drill's diameter unless holeFaces are given. Generates the toolpaths, reports every operation's warnings and errors and the machining time, and, with post, writes G-code through a post from Fusion's library (FANUC, Grbl, HAAS - Next Generation Control, ...). Opens the Manufacture workspace once if the document has no CAM yet, then returns to the user's workspace. Journaled.",+            "properties": {+              "bodies": {+                "items": {+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "name": {+                "type": "string"+              },+              "operationId": {+                "type": "string"+              },+              "operations": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "holeFaces": {+                      "items": {+                        "type": "object"+                      },+                      "maxItems": 512,+                      "type": "array"+                    },+                    "name": {+                      "type": "string"+                    },+                    "parameters": {+                      "type": "object"+                    },+                    "strategy": {+                      "enum": [+                        "face",+                        "adaptive",+                        "contour",+                        "parallel",+                        "scallop",+                        "pocket_clearing",+                        "drill"+                      ],+                      "type": "string"+                    },+                    "tool": {+                      "additionalProperties": false,+                      "properties": {+                        "diameterMm": {+                          "exclusiveMinimum": 0,+                          "maximum": 200,+                          "type": "number"+                        },+                        "type": {+                          "description": "Tool type as Fusion names it: flat end mill, ball end mill, bull nose end mill, drill, chamfer mill, ...",+                          "type": "string"+                        }+                      },+                      "type": "object"+                    }+                  },+                  "required": [+                    "strategy"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "post": {+                "additionalProperties": false,+                "properties": {+                  "folder": {+                    "type": "string"+                  },+                  "machine": {+                    "type": "string"+                  },+                  "program": {+                    "type": "string"+                  }+                },+                "required": [+                  "folder"+                ],+                "type": "object"+              },+              "timeoutSeconds": {+                "maximum": 3600,+                "minimum": 10,+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "bodies",+              "operations"+            ],+            "type": "object"+          },+          "cam_tools": {+            "description": "List tools in Fusion's sample tool libraries (milling or hole making, metric), optionally of one type, with diameter in mm, so cam_job can name them.",+            "properties": {+              "library": {+                "enum": [+                  "milling",+                  "hole"+                ],+                "type": "string"+              },+              "limit": {+                "maximum": 500,+                "minimum": 1,+                "type": "integer"+              },+              "type": {+                "type": "string"+              }+            },+            "required": [+              "op"+            ],+            "type": "object"+          },+          "component_create": {+            "description": "Create a native internal component and its first occurrence in a Hybrid design. parent is a component definition; edits to it affect every instance. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "metadata": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "asPurchased": {+                    "type": "boolean"+                  },+                  "category": {+                    "description": "e.g. extrusion, fastener, printed, machined, sheet metal, electronics, cable.",+                    "maxLength": 60,+                    "minLength": 1,+                    "type": "string"+                  },+                  "currency": {+                    "description": "ISO 4217 code such as USD.",+                    "type": "string"+                  },+                  "description": {+                    "type": "string"+                  },+                  "excludeFromBom": {+                    "type": "boolean"+                  },+                  "finish": {+                    "maxLength": 120,+                    "type": "string"+                  },+                  "leadTimeDays": {+                    "maximum": 3650,+                    "minimum": 0,+                    "type": "integer"+                  },+                  "makeBuy": {+                    "enum": [+                      "make",+                      "buy"+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "notes": {+                    "maxLength": 2000,+                    "type": "string"+                  },+                  "partNumber": {+                    "type": "string"+                  },+                  "process": {+                    "description": "How a made part is made: 3D print, laser cut, CNC, bent sheet...",+                    "maxLength": 120,+                    "type": "string"+                  },+                  "revision": {+                    "maxLength": 40,+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "stock": {+                    "description": "The stock a linear part is cut from (2020, 4040, 8020-1010...): the cut list groups by it.",+                    "maxLength": 60,+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  },+                  "unitCost": {+                    "minimum": 0,+                    "type": "number"+                  }+                },+                "required": [],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name"+            ],+            "type": "object"+          },+          "component_metadata": {+            "description": "Update component-definition name/part number/description and persistent supplier or BOM attributes. Shared occurrences all see this metadata.",+            "properties": {+              "changes": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "asPurchased": {+                    "type": "boolean"+                  },+                  "category": {+                    "description": "e.g. extrusion, fastener, printed, machined, sheet metal, electronics, cable.",+                    "maxLength": 60,+                    "minLength": 1,+                    "type": "string"+                  },+                  "currency": {+                    "description": "ISO 4217 code such as USD.",+                    "type": "string"+                  },+                  "description": {+                    "type": "string"+                  },+                  "excludeFromBom": {+                    "type": "boolean"+                  },+                  "finish": {+                    "maxLength": 120,+                    "type": "string"+                  },+                  "leadTimeDays": {+                    "maximum": 3650,+                    "minimum": 0,+                    "type": "integer"+                  },+                  "makeBuy": {+                    "enum": [+                      "make",+                      "buy"+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "notes": {+                    "maxLength": 2000,+                    "type": "string"+                  },+                  "partNumber": {+                    "type": "string"+                  },+                  "process": {+                    "description": "How a made part is made: 3D print, laser cut, CNC, bent sheet...",+                    "maxLength": 120,+                    "type": "string"+                  },+                  "revision": {+                    "maxLength": 40,+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "stock": {+                    "description": "The stock a linear part is cut from (2020, 4040, 8020-1010...): the cut list groups by it.",+                    "maxLength": 60,+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  },+                  "unitCost": {+                    "minimum": 0,+                    "type": "number"+                  }+                },+                "required": [],+                "type": "object"+              },+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "changes"+            ],+            "type": "object"+          },+          "configuration_inspect": {+            "description": "Read the loaded Design configuration graph without activation or recompute: ordinary rows, the separate native reserved test row, all supported typed cells including inactive/test cells, exact controlled-source links and current ordinary row. Unreadable fields and unknown/theme/hierarchical/inserted scopes remain explicit incomplete diagnostics. Configuration lifecycle and configured-design model mutations remain disabled pending native recovery/archive gates.",+            "properties": {},+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "construction_axis": {+            "description": "Create a parametric axis from native references (edge/circular face/two intersecting planes/two distinct points). Root-space external geometry requires exact occurrence context. For cross-component geometry into a non-root target component, creationOccurrence must identify a root-context instance of that target. Returns component-space native axis geometry/health. No direct-only infinite-line or preview snap APIs.",+            "properties": {+              "component": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "creationOccurrence": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "entities": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 2,+                "minItems": 1,+                "type": "array"+              },+              "name": {+                "type": "string"+              },+              "type": {+                "enum": [+                  "edge",+                  "circular_face",+                  "two_planes",+                  "two_points"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "type",+              "entities"+            ],+            "type": "object"+          },+          "efficiency_report": {+            "description": "Read what makes the design slow to recompute, open and edit, held against the efficiency playbook (skills/fusion-design-efficiency): timeline make-up and health, Position snapshots, Move features, size, repeated definitions made by Paste New, instance-weighted faces, imported history, wires in a parametric design, big sketches, pattern compute options, modeled threads, meshes and empty components. Returns metrics and findings (rule, severity, measured, limit, fix). Read-only and needs no revision digest. It is journaled like bom_export, so a long report on a big design is followed with fusion_mech_operation_status after the relay's 60 s; passes past budgetSeconds are skipped and listed, with complete:false.",+            "properties": {+              "budgetSeconds": {+                "description": "Stop the costly passes after this many seconds (default 120).",+                "maximum": 600,+                "minimum": 5,+                "type": "number"+              },+              "computeTiming": {+                "description": "Also time a full computeAll (slow on big designs; default false).",+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "entity_delete": {+            "description": "Delete sketch geometry or independently deletable timeline features. Model transaction and semantic recovery cover downstream failures; document and external file deletion are excluded.",+            "properties": {+              "entity": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "entity"+            ],+            "type": "object"+          },+          "exploded_preview_create": {+            "description": "Create finite copied solid-BRep presentation graphics in the exact active blank unsaved Design proven by a committed current-session new_design result. Regenerates the guarded source plan; leaves source active. Exclusive session lease, no source moves/visibility writes, no model transaction, automatic document close, render or capture. Live capability and native backend qualification are separate from durable operation receipts.",+            "properties": {+              "creationOperationId": {+                "type": "string"+              },+              "expectedPlanId": {+                "type": "string"+              },+              "planner": {+                "additionalProperties": false,+                "properties": {+                  "playback": {+                    "enum": [+                      "explode",+                      "assemble"+                    ],+                    "type": "string"+                  },+                  "sampleTimes": {+                    "items": {+                      "maximum": 3600,+                      "minimum": 0,+                      "type": "number"+                    },+                    "maxItems": 62,+                    "type": "array"+                  },+                  "steps": {+                    "items": {+                      "additionalProperties": false,+                      "properties": {+                        "durationSeconds": {+                          "exclusiveMinimum": 0,+                          "maximum": 3600,+                          "type": "number"+                        },+                        "instruction": {+                          "type": "string"+                        },+                        "moves": {+                          "items": {+                            "additionalProperties": false,+                            "properties": {+                              "direction": {+                                "items": {+                                  "maximum": 1000000000.0,+                                  "minimum": -1000000000.0,+                                  "type": "number"+                                },+                                "maxItems": 3,+                                "minItems": 3,+                                "type": "array"+                              },+                              "distance": {+                                "exclusiveMinimum": 0,+                                "maximum": 1000000.0,+                                "type": "number"+                              },+                              "frame": {+                                "enum": [+                                  "world",+                                  "parent",+                                  "local"+                                ],+                                "type": "string"+                              },+                              "occurrence": {+                                "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                                "type": "object"+                              }+                            },+                            "required": [+                              "occurrence",+                              "direction",+                              "distance",+                              "frame"+                            ],+                            "type": "object"+                          },+                          "maxItems": 128,+                          "minItems": 1,+                          "type": "array"+                        },+                        "title": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "durationSeconds",+                        "moves"+                      ],+                      "type": "object"+                    },+                    "maxItems": 32,+                    "minItems": 1,+                    "type": "array"+                  },+                  "unit": {+                    "enum": [+                      "mm"+                    ],+                    "type": "string"+                  }+                },+                "required": [+                  "unit",+                  "steps"+                ],+                "type": "object"+              },+              "sessionId": {+                "type": "string"+              },+              "sourceTarget": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sourceTarget",+              "creationOperationId",+              "expectedPlanId",+              "planner"+            ],+            "type": "object"+          },+          "exploded_preview_dispose": {+            "description": "Delete only the exact retained graphics tree and leave the blank document open for caller. Supports a narrowly proven cleanup after unresolved terminal storage without rewriting that history; no global Undo or close. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration"+            ],+            "type": "object"+          },+          "exploded_preview_inspect": {+            "description": "Main-thread live preview ownership/geometry/history observation. Cached operation receipts do not establish current graphics liveness. Old-session history remains separately readable through mech_operation_status; no native reference adoption or lifecycle repair is provided here.",+            "properties": {+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "previewId"+            ],+            "type": "object"+          },+          "exploded_preview_sample": {+            "description": "Apply one server-stored absolute sample to exact-owned graphics; preserve active document. Source must remain unchanged. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sampleIndex": {+                "maximum": 63,+                "minimum": 0,+                "type": "integer"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration",+              "sampleIndex"+            ],+            "type": "object"+          },+          "exploded_preview_show": {+            "description": "Explicitly activate the exact-owned presentation in Fusion; refuse an intervening foreign active document. No OS foreground, camera change or capture. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration"+            ],+            "type": "object"+          },+          "exploded_view_plan": {+            "description": "Read-only source-bound exploded assembly plan. Normalized translation directions in immutable home world/parent/local axes; simultaneous moves within ordered steps. Descendants inherit ancestor translations once, plus own moves. Bounded deterministic sample matrices and exact home reverse endpoint. No native moves, graphics, BOM quantity changes, render/video or storyboard creation. Complete configuration identity required.",+            "properties": {+              "playback": {+                "enum": [+                  "explode",+                  "assemble"+                ],+                "type": "string"+              },+              "sampleTimes": {+                "items": {+                  "maximum": 3600,+                  "minimum": 0,+                  "type": "number"+                },+                "maxItems": 62,+                "type": "array"+              },+              "sessionId": {+                "type": "string"+              },+              "steps": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "durationSeconds": {+                      "exclusiveMinimum": 0,+                      "maximum": 3600,+                      "type": "number"+                    },+                    "instruction": {+                      "type": "string"+                    },+                    "moves": {+                      "items": {+                        "additionalProperties": false,+                        "properties": {+                          "direction": {+                            "items": {+                              "maximum": 1000000000.0,+                              "minimum": -1000000000.0,+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 3,+                            "type": "array"+                          },+                          "distance": {+                            "exclusiveMinimum": 0,+                            "maximum": 1000000.0,+                            "type": "number"+                          },+                          "frame": {+                            "enum": [+                              "world",+                              "parent",+                              "local"+                            ],+                            "type": "string"+                          },+                          "occurrence": {+                            "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                            "type": "object"+                          }+                        },+                        "required": [+                          "occurrence",+                          "direction",+                          "distance",+                          "frame"+                        ],+                        "type": "object"+                      },+                      "maxItems": 128,+                      "minItems": 1,+                      "type": "array"+                    },+                    "title": {+                      "type": "string"+                    }+                  },+                  "required": [+                    "durationSeconds",+                    "moves"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "unit": {+                "enum": [+                  "mm"+                ],+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "target",+              "unit",+              "steps"+            ],+            "type": "object"+          },+          "exploded_view_render": {+            "description": "Render an exploded-view animation for operators: play the same steps as exploded_view_plan on the real occurrences, save one viewport image per frame from a fixed camera (fitted to the most exploded state), then revert every move and verify each instance is back home and the document state unchanged. Refuses a design with an uncaptured move. Journaled; follow a long render with fusion_mech_operation_status. Returns the frame folder, timed captions from the steps' titles and instructions, and the ffmpeg line that joins the frames into MP4 (Fusion's API has no video export).",+            "properties": {+              "fit": {+                "description": "Fit the camera to the most exploded state first (default true); false keeps the current view.",+                "type": "boolean"+              },+              "folder": {+                "description": "Absolute folder on the PC for frame_00000.png ... (created if missing).",+                "type": "string"+              },+              "fps": {+                "description": "Frames per second (default 24).",+                "maximum": 60,+                "minimum": 1,+                "type": "integer"+              },+              "height": {+                "description": "Frame height in pixels (default 720).",+                "maximum": 2160,+                "minimum": 240,+                "type": "integer"+              },+              "holdSeconds": {+                "description": "Hold the last pose this long (default 1).",+                "maximum": 30,+                "minimum": 0,+                "type": "number"+              },+              "operationId": {+                "type": "string"+              },+              "overwrite": {+                "description": "Replace frames already in folder (default false).",+                "type": "boolean"+              },+              "playback": {+                "enum": [+                  "explode",+                  "assemble"+                ],+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "steps": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "durationSeconds": {+                      "exclusiveMinimum": 0,+                      "maximum": 3600,+                      "type": "number"+                    },+                    "instruction": {+                      "type": "string"+                    },+                    "moves": {+                      "items": {+                        "additionalProperties": false,+                        "properties": {+                          "direction": {+                            "items": {+                              "maximum": 1000000000.0,+                              "minimum": -1000000000.0,+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 3,+                            "type": "array"+                          },+                          "distance": {+                            "exclusiveMinimum": 0,+                            "maximum": 1000000.0,+                            "type": "number"+                          },+                          "frame": {+                            "enum": [+                              "world",+                              "parent",+                              "local"+                            ],+                            "type": "string"+                          },+                          "occurrence": {+                            "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                            "type": "object"+                          }+                        },+                        "required": [+                          "occurrence",+                          "direction",+                          "distance",+                          "frame"+                        ],+                        "type": "object"+                      },+                      "maxItems": 128,+                      "minItems": 1,+                      "type": "array"+                    },+                    "title": {+                      "type": "string"+                    }+                  },+                  "required": [+                    "durationSeconds",+                    "moves"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "unit": {+                "enum": [+                  "mm"+                ],+                "type": "string"+              },+              "width": {+                "description": "Frame width in pixels (default 1280).",+                "maximum": 3840,+                "minimum": 320,+                "type": "integer"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "unit",+              "steps",+              "folder"+            ],+            "type": "object"+          },+          "export": {+            "description": "Export entire design using runtime-checked API. Preflight and unique same-filesystem staging preserve the destination on failure; publish only nonempty verified output. Availability differs by Fusion build. STL numeric coordinates use mm.",+            "properties": {+              "format": {+                "default": "step",+                "enum": [+                  "step",+                  "stl",+                  "3mf",+                  "f3d",+                  "iges",+                  "sat",+                  "smt",+                  "usdz",+                  "fbx",+                  "skp"+                ]+              },+              "outputPath": {+                "type": "string"+              },+              "overwrite": {+                "default": false,+                "type": "boolean"+              },+              "refinement": {+                "default": "medium",+                "enum": [+                  "low",+                  "medium",+                  "high"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "outputPath"+            ],+            "type": "object"+          },+          "feature_create": {+            "description": "Create a typed native solid feature. All length quantities are mm (or expressions), angles deg. Cut/intersect require explicit participant bodies. Join needs a single existing component body; combine selects multiple bodies explicitly. Feature availability is runtime-checked; missing APIs fail before commit. Rectangular and circular patterns repeat exactly one of bodies, features, faces or occurrences (a component pattern, built in the occurrences' shared parent so the part stays one definition); computeOption is identical (default), optimized or adjust and does not apply to component patterns.",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "direction": {+                    "enum": [+                      "positive",+                      "negative",+                      "symmetric"+                    ]+                  },+                  "distance": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "taper": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "extrude"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "distance"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "revolve"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "axis",+                  "angle"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "edges": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "radius": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "fillet"+                    ]+                  }+                },+                "required": [+                  "type",+                  "edges",+                  "radius"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "distance": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "edges": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "chamfer"+                    ]+                  }+                },+                "required": [+                  "type",+                  "edges",+                  "distance"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "thickness": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "type": {+                    "enum": [+                      "shell"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "thickness"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "depth": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "diameter": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "points": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "hole"+                    ]+                  }+                },+                "required": [+                  "type",+                  "points",+                  "diameter",+                  "depth",+                  "bodies"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "loft"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "path": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "sweep"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "path"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "body": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keepTools": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "tools": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "type": {+                    "enum": [+                      "combine"+                    ]+                  }+                },+                "required": [+                  "type",+                  "body",+                  "tools",+                  "operation"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "extend": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "split"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies",+                  "plane"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "origin": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "translation": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "type": {+                    "enum": [+                      "move"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "mirror"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies",+                  "plane"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "axis2": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "computeOption": {+                    "description": "identical (default) repeats the first result; optimized is fastest but can drop instances that touch other geometry; adjust recomputes every instance (slowest). Ignored for occurrences.",+                    "enum": [+                      "identical",+                      "optimized",+                      "adjust"+                    ]+                  },+                  "count": {+                    "maximum": 1000,+                    "minimum": 2,+                    "type": "integer"+                  },+                  "count2": {+                    "maximum": 1000,+                    "minimum": 1,+                    "type": "integer"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "features": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrences": {+                    "items": {+                      "description": "Occurrence reference returned by inspect in this document revision; all must share one parent component, where the component pattern is built.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "spacing": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "spacing2": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "rectangular_pattern"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "count",+                  "spacing"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "computeOption": {+                    "description": "identical (default) repeats the first result; optimized is fastest but can drop instances that touch other geometry; adjust recomputes every instance (slowest). Ignored for occurrences.",+                    "enum": [+                      "identical",+                      "optimized",+                      "adjust"+                    ]+                  },+                  "count": {+                    "maximum": 1000,+                    "minimum": 2,+                    "type": "integer"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "features": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrences": {+                    "items": {+                      "description": "Occurrence reference returned by inspect in this document revision; all must share one parent component, where the component pattern is built.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "circular_pattern"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "count"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "draft"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "plane",+                  "angle"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "designation": {+                    "type": "string"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "internal": {+                    "type": "boolean"+                  },+                  "modeled": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "threadClass": {+                    "type": "string"+                  },+                  "threadType": {+                    "type": "string"+                  },+                  "type": {+                    "enum": [+                      "thread"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "internal",+                  "threadType",+                  "designation",+                  "threadClass"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "angle": {},+              "axis": {},+              "axis2": {},+              "bodies": {},+              "body": {},+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "computeOption": {},+              "count": {},+              "count2": {},+              "depth": {},+              "designation": {},+              "diameter": {},+              "direction": {},+              "distance": {},+              "edges": {},+              "extend": {},+              "faces": {},+              "features": {},+              "internal": {},+              "keepTools": {},+              "modeled": {},+              "name": {+                "type": "string"+              },+              "occurrences": {},+              "operation": {},+              "origin": {},+              "path": {},+              "plane": {},+              "points": {},+              "profiles": {},+              "radius": {},+              "spacing": {},+              "spacing2": {},+              "tangentChain": {},+              "taper": {},+              "thickness": {},+              "threadClass": {},+              "threadType": {},+              "tools": {},+              "translation": {},+              "type": {+                "enum": [+                  "extrude",+                  "revolve",+                  "fillet",+                  "chamfer",+                  "shell",+                  "hole",+                  "loft",+                  "sweep",+                  "combine",+                  "split",+                  "move",+                  "mirror",+                  "rectangular_pattern",+                  "circular_pattern",+                  "draft",+                  "thread"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type"+            ],+            "type": "object"+          },+          "feature_edit": {+            "description": "Rename/suppress a feature or change expressions of model parameters whose createdBy is that exact feature; read health and abort on downstream errors.",+            "properties": {+              "feature": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "parameters": {+                "additionalProperties": {+                  "type": "string"+                },+                "type": "object"+              },+              "suppressed": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "feature"+            ],+            "type": "object"+          },+          "geometry_query": {+            "description": "Complete body-scoped topology query, no arbitrary first-match selection. selection one (default) refuses zero/multiple matches; many may return empty. Geometry types are exact native types; size ranges inclusive in mm/mm2, near is minimum distance in the explicit frame; direction is outward planar face normal or linear edge tangent. Returned refs retain instance context even for component-space filters. Exceeding maxResults fails rather than truncating.",+            "properties": {+              "body": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "filters": {+                "additionalProperties": false,+                "properties": {+                  "area": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "direction": {+                    "additionalProperties": false,+                    "properties": {+                      "orientation": {+                        "enum": [+                          "same",+                          "parallel"+                        ]+                      },+                      "tolerance": {+                        "maximum": 90,+                        "minimum": 0,+                        "type": "number"+                      },+                      "vector": {+                        "items": {+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "vector"+                    ],+                    "type": "object"+                  },+                  "length": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "near": {+                    "additionalProperties": false,+                    "properties": {+                      "point": {+                        "items": {+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "tolerance": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [+                      "point",+                      "tolerance"+                    ],+                    "type": "object"+                  },+                  "radius": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "Plane",+                      "Cylinder",+                      "Cone",+                      "Sphere",+                      "Torus",+                      "NurbsSurface",+                      "Line3D",+                      "Arc3D",+                      "Circle3D",+                      "Ellipse3D",+                      "EllipticalArc3D",+                      "NurbsCurve3D",+                      "Point3D",+                      "degenerate"+                    ]+                  }+                },+                "required": [],+                "type": "object"+              },+              "kind": {+                "enum": [+                  "faces",+                  "edges",+                  "vertices"+                ]+              },+              "maxResults": {+                "maximum": 1024,+                "minimum": 1,+                "type": "integer"+              },+              "selection": {+                "enum": [+                  "one",+                  "many"+                ]+              },+              "space": {+                "enum": [+                  "root",+                  "component"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "body",+              "kind",+              "space"+            ],+            "type": "object"+          },+          "health": {+            "description": "Read timeline warnings/errors. recompute:true also requires current target revision, sessionId and operationId.",+            "properties": {+              "recompute": {+                "default": false,+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "inspect": {+            "description": "Inspect the active Design without mutation. Returns target identity/revision, native component-space bodies and occurrence transforms, parameters and feature health.",+            "properties": {+              "bodyMetrics": {+                "description": "Read each body's physical properties and bounding box (about 10 ms a body). Default: true for designs of 200 components or fewer.",+                "type": "boolean"+              },+              "componentProperties": {+                "description": "Read each component's part number and description (cloud reads, about 0.6 s each per component on a cloud document). Default: true for 200 components or fewer.",+                "type": "boolean"+              },+              "detail": {+                "description": "target: only the target, document and counts (what a write or a BOM needs), for an assembly too big for a full inspect inside the relay's budget. Default full.",+                "enum": [+                  "full",+                  "target"+                ]+              },+              "health": {+                "description": "Read timeline health (about 22 ms a timeline item). Default: true for timelines of 200 items or fewer; otherwise use op health.",+                "type": "boolean"+              }+            },+            "required": [+              "op"+            ],+            "type": "object"+          },+          "inspect_entity": {+            "properties": {+              "entity": {+                "description": "Exact reference returned by inspect; resolves uniquely with document/revision/type/occurrence guards.",+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "entity"+            ],+            "type": "object"+          },+          "interference": {+            "description": "Analyze root-context occurrences/body proxies; returns overlap volume mm3 or touching. Does not create interference bodies.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 2,+                "type": "array"+              },+              "includeTouching": {+                "type": "boolean"+              },+              "volumeTolerance": {+                "minimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "target",+              "entities"+            ],+            "type": "object"+          },+          "joint_create": {+            "description": "Create an as-built joint without moving occurrences. Non-rigid motion requires explicit joint geometry; x/y/z are joint-coordinate directions. Limits and drive values use mm/deg. Seven native motion types; ball uses joint Z pitch/X yaw; planar uses native primary slide direction reported on readback. Use regular_joint_create for geometry-solving placement.",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "rigid"+                    ]+                  }+                },+                "required": [+                  "type"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "revolute"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "slider"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "cylindrical"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideAxis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "pin_slot"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "primarySlideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "primarySlideValue": {+                    "type": "number"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "secondarySlideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "secondarySlideValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "planar"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "pitchLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "pitchValue": {+                    "type": "number"+                  },+                  "rollLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rollValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "ball"+                    ]+                  },+                  "yawLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "yawValue": {+                    "type": "number"+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "occurrenceOne": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "occurrenceTwo": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "suppressed": {+                "type": "boolean"+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type",+              "occurrenceOne",+              "occurrenceTwo"+            ],+            "type": "object"+          },+          "joint_delete": {+            "description": "Delete one selected Joint or AsBuiltJoint with recovery verification.",+            "properties": {+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "joint_edit": {+            "description": "Edit joint name/suppression, enabled limits, rest and drive values; wrong motion type or out-of-limit values fail with recovery. For driven root joints, active motion links must preserve their settings and their partner motion must follow the native ratio; a coupling mismatch aborts.",+            "properties": {+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "suppressed": {+                "type": "boolean"+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "joint_origin_create": {+            "description": "Create a native component-definition joint origin from guarded native geometry, with mm offsets/deg angle and optional straight axis references. Child occurrence origin references are exposed by inspect_entity(occurrence).",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "flipped": {+                "type": "boolean"+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "edge": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetZ": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "xAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "zAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "geometry"+            ],+            "type": "object"+          },+          "joint_origin_delete": {+            "description": "Delete a native joint origin; unhealthy downstream joints cause transaction rollback.",+            "properties": {+              "origin": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "origin"+            ],+            "type": "object"+          },+          "joint_origin_edit": {+            "description": "Edit a native joint origin definition; rolls before its timeline item and restores the original marker in finally. Recomputes and verifies attachment, axes, offsets, angle, name and flip.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "edge": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetZ": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "origin": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "xAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "zAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "origin"+            ],+            "type": "object"+          },+          "material_assign": {+            "description": "Assign a loaded library or document material to an exact native Component/BRepBody; verify material ID readback with model transaction recovery. Query assembly_properties for resulting mass.",+            "properties": {+              "entity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "libraryId": {+                "type": "string"+              },+              "materialId": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "entity",+              "materialId"+            ],+            "type": "object"+          },+          "material_list": {+            "description": "List loaded material libraries and matching materials by stable library/material IDs. Omit libraryId to search the document's materials and then every loaded library; each row names the libraryId material_assign needs (null for the document's own).",+            "properties": {+              "libraryId": {+                "type": "string"+              },+              "limit": {+                "maximum": 1000,+                "minimum": 1,+                "type": "integer"+              },+              "query": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "mcmaster_discover": {+            "description": "Discover Fusion native Insert McMaster-Carr command and requirements in the active design.",+            "properties": {},+            "required": [+              "op"+            ],+            "type": "object"+          },+          "mcmaster_open": {+            "description": "Invoke Fusion native McMaster UI in the targeted Hybrid design. Interactive external operation: completion/insert/cancel stays with Fusion; inspect afterward. Idempotency records launch only.",+            "properties": {},+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "measure": {+            "description": "Native engineering minimum distance or angle in root assembly space. Non-root definition refs require an occurrence context. Distance needs2 entities; angle needs2 lines/planes or3 points (second apex). Returns mm/deg and native witness positions in root mm. witnessValidation identifies native points or native geometry directions used for valid parallel angles with degenerate native points; degenerate point angles and unavailable/inconsistent witnesses fail.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "space": {+                "enum": [+                  "root"+                ]+              },+              "type": {+                "enum": [+                  "distance",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "type",+              "space",+              "entities"+            ],+            "type": "object"+          },+          "motion_link_create": {+            "description": "Create a native motion link between two root-owned joints, or two different motions of jointOne when jointTwo is omitted. Positive ratio magnitudes use mm for translation and deg for rotation; reversed selects opposite direction. Requires the November 2025+ API; no script fallback.",+            "properties": {+              "jointOne": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "jointTwo": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "motionOne": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "motionTwo": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "reversed": {+                "type": "boolean"+              },+              "valueOne": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "valueTwo": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "jointOne",+              "motionOne",+              "motionTwo",+              "valueOne",+              "valueTwo"+            ],+            "type": "object"+          },+          "motion_link_delete": {+            "description": "Delete a root-owned motion link under the same transaction/recovery contract.",+            "properties": {+              "link": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "link"+            ],+            "type": "object"+          },+          "motion_link_edit": {+            "description": "Edit a root-owned motion link ratio, degree-of-freedom pair, direction, name or suppression. Joint membership is immutable; recreate the link to change members. Verify exact joint identities, ratio, flags and health.",+            "properties": {+              "link": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "motionOne": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "motionTwo": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "reversed": {+                "type": "boolean"+              },+              "suppressed": {+                "type": "boolean"+              },+              "valueOne": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "valueTwo": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "link"+            ],+            "type": "object"+          },+          "new_design": {+            "description": "Create an unnamed unsaved parametric hybrid Design; name is retained as requestedName metadata to keep failure recovery free of save dialogs. Optional box dimensions in mm create a driving-parameter fixture. Never edits an existing document.",+            "properties": {+              "box": {+                "additionalProperties": false,+                "properties": {+                  "depth": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  },+                  "height": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  },+                  "width": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  }+                },+                "required": [+                  "width",+                  "height",+                  "depth"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId"+            ],+            "type": "object"+          },+          "occurrence_delete": {+            "description": "Delete one selected occurrence through the shared transaction executor.",+            "properties": {+              "occurrence": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "occurrence"+            ],+            "type": "object"+          },+          "occurrence_insert": {+            "description": "Insert another occurrence of an existing definition; independentCopy:true uses Paste New to create a separate definition. Nested placement is in parent component coordinates. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "independentCopy": {+                "type": "boolean"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "component"+            ],+            "type": "object"+          },+          "occurrence_update": {+            "description": "Set occurrence pose in its assembly context and capture position; explicit grounding/ungrounding. Grounded or constrained transforms fail with recovery.",+            "properties": {+              "grounded": {+                "type": "boolean"+              },+              "groundedToParent": {+                "type": "boolean"+              },+              "method": {+                "description": "How a new transform is kept. auto (default): edit the occurrence's initial position when Fusion allows it (a root-level occurrence without joints or patterns), which adds nothing to the timeline, else capture a Position snapshot. initial_position: refuse rather than capture. capture: always capture a snapshot. The reply's placement says which was used.",+                "enum": [+                  "auto",+                  "initial_position",+                  "capture"+                ],+                "type": "string"+              },+              "occurrence": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "occurrence"+            ],+            "type": "object"+          },+          "parameter_batch": {+            "description": "Atomic sequential create/set/delete parameter edits with one recompute+health gate; delete supports user parameters only. Any failure aborts all edits and reports semantic recovery.",+            "properties": {+              "changes": {+                "items": {+                  "oneOf": [+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "create"+                          ]+                        },+                        "comment": {+                          "type": "string"+                        },+                        "expression": {+                          "type": "string"+                        },+                        "name": {+                          "type": "string"+                        },+                        "unit": {+                          "enum": [+                            "mm",+                            "deg",+                            "kg",+                            ""+                          ]+                        }+                      },+                      "required": [+                        "action",+                        "name",+                        "expression",+                        "unit"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "set"+                          ]+                        },+                        "expression": {+                          "type": "string"+                        },+                        "name": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "action",+                        "name",+                        "expression"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "delete"+                          ]+                        },+                        "name": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "action",+                        "name"+                      ],+                      "type": "object"+                    }+                  ]+                },+                "maxItems": 128,+                "minItems": 1,+                "type": "array"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "changes"+            ],+            "type": "object"+          },+          "parameter_create": {+            "properties": {+              "comment": {+                "type": "string"+              },+              "expression": {+                "type": "string"+              },+              "name": {+                "type": "string"+              },+              "unit": {+                "enum": [+                  "mm",+                  "deg",+                  "kg",+                  ""+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name",+              "expression",+              "unit"+            ],+            "type": "object"+          },+          "parameter_set": {+            "description": "Set an expression, recompute and inspect health. Failure restores old expression and reports a semantic recovery witness; not an atomic transaction.",+            "properties": {+              "expression": {+                "type": "string"+              },+              "name": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name",+              "expression"+            ],+            "type": "object"+          },+          "plane_create": {+            "description": "Create offset plane (offset in mm) or angled plane around axis (angle in deg).",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "offset": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "offset"+                    ]+                  }+                },+                "required": [+                  "type",+                  "offset"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "angle"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "angle"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "angle": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "oneOf": [+                  {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              },+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "offset": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "plane": {+                "oneOf": [+                  {+                    "enum": [+                      "xy",+                      "xz",+                      "yz"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              },+              "type": {+                "enum": [+                  "offset",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type"+            ],+            "type": "object"+          },+          "regular_joint_create": {+            "description": "Create a geometry-solving regular joint in the root component using two distinct instance-context attachments or joint origins. All seven native motion families; offsets mm, angle and angular limits deg. Read back freshly resolved attachment graph, native parameters and root-space occurrence placement. Root/non-root sides must be unambiguous; both grounded and ancestor/descendant pairs are refused. Inferred joints are unsupported. Existing pending positions must be captured or reverted first. Before applying drive values, checks native joint-transform anchor offset magnitude/axiality and zero-angle axis collinearity. Native joint matrices have explicit provenance; physical angle/flip sense requires independent occurrence-geometry acceptance.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometryOne": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "geometryTwo": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "locked": {+                "type": "boolean"+              },+              "name": {+                "type": "string"+              },+              "offset": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type",+              "geometryOne",+              "geometryTwo"+            ],+            "type": "object"+          },+          "regular_joint_edit": {+            "description": "Redefine root-owned regular joint geometry, motion family, offsets, angle, flip or lock. Restore timeline in finally and verify after recompute. Use joint_edit for name, suppression, limits and drive values; joint_delete for deletion.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometryOne": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "geometryTwo": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "locked": {+                "type": "boolean"+              },+              "offset": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "render_image": {+            "description": "Render a photoreal image with Fusion's local renderer: from a standard view fitted to the design (iso by default) or the current view, at a size and quality (0 to 100; 75 by default), optionally on a transparent background or without the ground. Waits for the render, then restores the camera and every render setting it changed. Journaled: a large, high-quality render runs for minutes, so follow it with fusion_mech_operation_status. Fusion's API cannot choose the render environment; the document's own is used.",+            "properties": {+              "filename": {+                "description": "Absolute .png or .jpg path on the PC.",+                "type": "string"+              },+              "ground": {+                "description": "Show the ground plane (shadows and reflections); default leaves the document's setting.",+                "type": "boolean"+              },+              "height": {+                "maximum": 4320,+                "minimum": 64,+                "type": "integer"+              },+              "operationId": {+                "type": "string"+              },+              "overwrite": {+                "type": "boolean"+              },+              "quality": {+                "maximum": 100,+                "minimum": 0,+                "type": "integer"+              },+              "timeoutSeconds": {+                "maximum": 3600,+                "minimum": 10,+                "type": "number"+              },+              "transparent": {+                "type": "boolean"+              },+              "view": {+                "enum": [+                  "iso",+                  "iso-left",+                  "front",+                  "back",+                  "top",+                  "bottom",+                  "left",+                  "right",+                  "current"+                ],+                "type": "string"+              },+              "width": {+                "maximum": 7680,+                "minimum": 64,+                "type": "integer"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename"+            ],+            "type": "object"+          },+          "render_scene_inspect": {+            "description": "Guarded main-thread read of current viewport camera, render settings and up to 32 environments. Optional detached world-mm camera is constructed and read back without viewport assignment. Missing fields return PARTIAL; observationComplete covers only bounded available scope. sceneWitnessComplete and renderQualified remain false. No rendering, workspace activation or scene writes.",+            "properties": {+              "camera": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "extents": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": 1e-06,+                          "type": "number"+                        },+                        "maxItems": 2,+                        "minItems": 2,+                        "type": "array"+                      },+                      "eye": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "space": {+                        "enum": [+                          "world"+                        ],+                        "type": "string"+                      },+                      "target": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "type": {+                        "enum": [+                          "orthographic"+                        ],+                        "type": "string"+                      },+                      "unit": {+                        "enum": [+                          "mm"+                        ],+                        "type": "string"+                      },+                      "upVector": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "type",+                      "space",+                      "unit",+                      "eye",+                      "target",+                      "upVector",+                      "extents"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "angleUnit": {+                        "enum": [+                          "deg"+                        ],+                        "type": "string"+                      },+                      "eye": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "perspectiveAngle": {+                        "exclusiveMinimum": 0,+                        "maximum": 179.999999999,+                        "type": "number"+                      },+                      "space": {+                        "enum": [+                          "world"+                        ],+                        "type": "string"+                      },+                      "target": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "type": {+                        "enum": [+                          "perspective"+                        ],+                        "type": "string"+                      },+                      "unit": {+                        "enum": [+                          "mm"+                        ],+                        "type": "string"+                      },+                      "upVector": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "type",+                      "space",+                      "unit",+                      "eye",+                      "target",+                      "upVector",+                      "perspectiveAngle",+                      "angleUnit"+                    ],+                    "type": "object"+                  }+                ]+              },+              "maxEnvironments": {+                "maximum": 32,+                "minimum": 0,+                "type": "integer"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "target"+            ],+            "type": "object"+          },+          "rigid_group_create": {+            "description": "Create a native rigid group from exact occurrence instances; includeChildren defaults true.",+            "properties": {+              "includeChildren": {+                "type": "boolean"+              },+              "name": {+                "type": "string"+              },+              "occurrences": {+                "items": {+                  "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 2,+                "type": "array"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "occurrences"+            ],+            "type": "object"+          },+          "rigid_group_delete": {+            "description": "Delete an exact rigid group with transaction recovery.",+            "properties": {+              "group": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "group"+            ],+            "type": "object"+          },+          "rigid_group_edit": {+            "description": "Rename or suppress an exact rigid group with transaction recovery.",+            "properties": {+              "group": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "suppressed": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "group"+            ],+            "type": "object"+          },+          "sketch_constraint": {+            "description": "Constrain entities in one sketch. midpoint order is point,line; symmetry order entity1,entity2,symmetryLine. fix sets one entity fixed.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "type": {+                "enum": [+                  "horizontal",+                  "vertical",+                  "coincident",+                  "parallel",+                  "perpendicular",+                  "tangent",+                  "equal",+                  "concentric",+                  "collinear",+                  "midpoint",+                  "symmetry",+                  "fix"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "type",+              "entities"+            ],+            "type": "object"+          },+          "sketch_create": {+            "description": "Create a native component-definition sketch on an origin/construction plane or planar face. Coordinates in subsequent geometry are sketch-space mm.",+            "properties": {+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "plane": {+                "oneOf": [+                  {+                    "enum": [+                      "xy",+                      "xz",+                      "yz"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "sketch_curve_edit": {+            "description": "Edit one native sketch curve with sketch-space mm pick. trim removes the nearest segment; extend chooses nearest endpoint; split requires an interior on-curve point; break uses neighboring intersections. Fresh replacement refs are returned; original may be deleted. In-place extend returns the original with a fresh ref only after its geometry change survives recompute. No change or empty break/split fails. Full trim deletion requires allowDelete true. Linked/derived/deferred-compute geometry refused.",+            "properties": {+              "action": {+                "enum": [+                  "trim",+                  "extend",+                  "split",+                  "break"+                ]+              },+              "allowDelete": {+                "type": "boolean"+              },+              "createConstraints": {+                "type": "boolean"+              },+              "curve": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "pick": {+                "items": {+                  "type": "number"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "sketch",+              "curve",+              "action",+              "pick"+            ],+            "type": "object"+          },+          "sketch_diagnostics": {+            "description": "Read native sketch health/message, fully-constrained/fixed/linked/reference flags, geometric constraints and driving dimensions. Reports no solver DOF count or conflict-set explanation; no recompute/mutation.",+            "properties": {+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sketch"+            ],+            "type": "object"+          },+          "sketch_dimension": {+            "description": "Add driving dimensions. Distance uses two point references; radius/diameter one curve; angle two lines. Numeric expressions use mm or deg.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "expression": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "parameterName": {+                "type": "string"+              },+              "position": {+                "items": {+                  "type": "number"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "type": {+                "enum": [+                  "distance",+                  "horizontal",+                  "vertical",+                  "radius",+                  "diameter",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "type",+              "entities",+              "expression",+              "position"+            ],+            "type": "object"+          },+          "sketch_edit": {+            "description": "Move sketch points/endpoints/centers in sketch-space mm, change radius or construction/fixed flags; solver failure aborts the operation.",+            "properties": {+              "changes": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "center": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "construction": {+                    "type": "boolean"+                  },+                  "end": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "fixed": {+                    "type": "boolean"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "radius": {+                    "type": "number"+                  },+                  "start": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              },+              "entity": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "entity",+              "changes"+            ],+            "type": "object"+          },+          "sketch_geometry": {+            "description": "Create a transactionally grouped set of sketch primitives. Numeric geometry uses mm and arc sweeps/polygon angles use deg.",+            "properties": {+              "items": {+                "items": {+                  "oneOf": [+                    {+                      "additionalProperties": false,+                      "properties": {+                        "position": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "point"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "position"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "line"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "rectangle"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "radius": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        },+                        "type": {+                          "enum": [+                            "circle"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "radius"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "sweep": {+                          "type": "number"+                        },+                        "type": {+                          "enum": [+                            "arc"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "start",+                        "sweep"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "angle": {+                          "type": "number"+                        },+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "radius": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        },+                        "sides": {+                          "maximum": 128,+                          "minimum": 3,+                          "type": "integer"+                        },+                        "type": {+                          "enum": [+                            "polygon"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "radius",+                        "sides"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "slot"+                          ]+                        },+                        "width": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end",+                        "width"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "closed": {+                          "type": "boolean"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "points": {+                          "items": {+                            "items": {+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 2,+                            "type": "array"+                          },+                          "maxItems": 128,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "spline"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "points"+                      ],+                      "type": "object"+                    }+                  ]+                },+                "maxItems": 128,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "items"+            ],+            "type": "object"+          },+          "sketch_offset": {+            "description": "Modern createOffsetInput/addOffset2. Curves must be native 2D, unique, in connected flow order (never reordered). Nonzero signed mm number/expression: positive right, negative left; a single circle/ellipse positive outside. Topology matched defaults true. Read back native signed distance, parent/child refs and controlling parameter after recompute. No retired Sketch.offset fallback.",+            "properties": {+              "curves": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "distance": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "topologyMatched": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "sketch",+              "curves",+              "distance"+            ],+            "type": "object"+          },+          "sketch_project": {+            "description": "Project selected topology into a sketch with Fusion associative projection.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "entities"+            ],+            "type": "object"+          },+          "transaction_probe": {+            "description": "Verify runtime PTransaction abort+commit using temporary user parameters, remove probe data and compare semantic restoration. Required once per running add-in session before feature/sketch/atomic-batch writes. Returns fresh target; inspect again for current references.",+            "properties": {},+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          }+        },+        "sessionId": "str",+        "success": "bool",+        "transactions": "object"+      },+      "statusVerb": null,+      "summary": "Discover typed mechanical operations, exact input schemas, units, recovery limitations and the current add-in session ID (null while no add-in session is live). Served by the bridge exe from the add-in's schema and session file.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "operationId": "required str",+        "sessionId": "required str"+      },+      "longRunning": false,+      "name": "fusion_mech_operation_status",+      "output": {+        "currentSessionId": "str",+        "historical": "bool",+        "history": "durable identity/phase/timestamps",+        "observedResult": "bounded unconfirmed current-session result or null",+        "phase": "admitted|dispatched|executing|succeeded|failed|not_executed",+        "reconciliationRequired": "bool",+        "result": "recorded terminal result or null",+        "state": "running|succeeded|failed|interrupted|reconciliation_required",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Read durable typed-operation history by recorded sessionId and operationId, including after HTTP timeout or add-in restart. Returns the recorded request digest, source version, target identity, phase/timestamps and terminal result. Historical nonterminal work is interrupted/unknown and never replayed. Admission without a durable dispatch claim or uncertain persistence requires reconciliation. Missing history never proves no execution. The bridge exe reads the journal itself, so this answers while Fusion is busy, hung or closed; it never starts/restarts Fusion, touches windows or dismisses dialogs. SQLite recovery may repair only the app-owned journal.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "op": "inspect"+      },+      "input": {+        "op": "required enum: inspect|inspect_entity|new_design|parameter_set|parameter_create|health|export|transaction_probe|sketch_create|sketch_geometry|sketch_constraint|sketch_dimension|sketch_project|sketch_edit|plane_create|feature_create|feature_edit|entity_delete|parameter_batch|component_create|occurrence_insert|occurrence_update|occurrence_delete|component_metadata|joint_create|joint_edit|joint_delete|interference|bom|bom_export|cad_import|mcmaster_discover|mcmaster_open|material_list|material_assign|rigid_group_create|rigid_group_edit|rigid_group_delete|assembly_properties|geometry_query|measure|sketch_curve_edit|sketch_offset|construction_axis|sketch_diagnostics|joint_origin_create|joint_origin_edit|joint_origin_delete|regular_joint_create|regular_joint_edit|motion_link_create|motion_link_edit|motion_link_delete|configuration_inspect|render_scene_inspect|exploded_view_plan|exploded_preview_create|exploded_preview_sample|exploded_preview_show|exploded_preview_dispose|exploded_preview_inspect|efficiency_report|exploded_view_render|render_image|cam_tools|cam_job|cam_inspect",+        "operationId": "required unique write ID; reuse unchanged for retry",+        "operationSchemas": {+          "assembly_properties": {+            "description": "High-accuracy physical properties of whole root assembly (default) or an exact Component/Occurrence/BRepBody. Returns mass kg, volume mm3, area mm2, center of mass mm, mean density kg/mm3 and definition/instance coordinate scope.",+            "properties": {+              "entity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "bom": {+            "description": "Structured component-definition and instance BOM; quantities by actual identity, root bodies plus nested children; purchased metadata collapses subtrees unless exploded. Physical mass includes all unsuppressed bodies exactly once per instance. Includes exact current active configuration provenance; incomplete configuration scope refuses. Visibility does not remove quantity. Returns the indented structure with item numbers, the flat purchasing list (make/buy, category, cost, mass), the extrusion cut list (and a bar plan with stockLengthMm), the fastener rollup, totals with cost coverage, and warnings for missing data.",+            "properties": {+              "budgetSeconds": {+                "description": "Stop the cloud reads of part numbers and descriptions (about 0.5 s each on a cloud assembly) once the call has run this long (default 40); the rest come back as nativePending, and the next run continues from what this one read.",+                "maximum": 3600,+                "minimum": 5,+                "type": "number"+              },+              "currency": {+                "description": "ISO 4217 code (USD, EUR) for lines with a unit cost and none of their own; default USD.",+                "type": "string"+              },+              "explodePurchased": {+                "type": "boolean"+              },+              "includeLibraries": {+                "description": "Count body-less groups named as a library (\"Vendor library\", a palette of parts kept to copy from). Default false: they are listed in excluded with reason library_group.",+                "type": "boolean"+              },+              "inferKits": {+                "description": "Count an assembly as one bought line when its name reads as a bought product (an imported .stp/STEP translator model, a McMaster number, a vendor note such as \"(vendor STEP)\" or \"(modelled)\", a maker's name) or its children are a circuit board's footprints. Default true. An explicit asPurchased or makeBuy wins, and so does a name that says it is made here (fabricated, 3D printed, machined).",+                "type": "boolean"+              },+              "kerfMm": {+                "description": "Saw kerf per cut in the bar plan; default 3.",+                "maximum": 50,+                "minimum": 0,+                "type": "number"+              },+              "nativeProperties": {+                "description": "Read part numbers and descriptions (default true; cached per component revision). false gives the structure, quantities and metadata attributes in seconds on a big cloud assembly.",+                "type": "boolean"+              },+              "physicalTotals": {+                "description": "Sum mass and volume over every body instance (default true). false skips that walk on a big assembly; per-line unit mass is still read.",+                "type": "boolean"+              },+              "stockLengthMm": {+                "description": "Stock bar length for the cut list's bar plan (first-fit decreasing).",+                "exclusiveMinimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "bom_export": {+            "description": "Export flat grouped purchasing rows or structured parent/path/depth instance rows and supplier provenance to CSV with exclusive/atomic publication. This external effect is separate from model transactions. Both CSV modes include document/revision and current active configuration table/row provenance.",+            "properties": {+              "budgetSeconds": {+                "description": "As for bom (default 40): rows of components whose part number was left for later have it blank, and the response's nativePending counts them; export again to fill them in.",+                "maximum": 3600,+                "minimum": 5,+                "type": "number"+              },+              "currency": {+                "description": "ISO 4217 code (USD, EUR) for lines with a unit cost and none of their own; default USD.",+                "type": "string"+              },+              "explodePurchased": {+                "type": "boolean"+              },+              "filename": {+                "type": "string"+              },+              "includeLibraries": {+                "description": "Count body-less groups named as a library (\"Vendor library\", a palette of parts kept to copy from). Default false: they are listed in excluded with reason library_group.",+                "type": "boolean"+              },+              "inferKits": {+                "description": "Count an assembly as one bought line when its name reads as a bought product (an imported .stp/STEP translator model, a McMaster number, a vendor note such as \"(vendor STEP)\" or \"(modelled)\", a maker's name) or its children are a circuit board's footprints. Default true. An explicit asPurchased or makeBuy wins, and so does a name that says it is made here (fabricated, 3D printed, machined).",+                "type": "boolean"+              },+              "kerfMm": {+                "description": "Saw kerf per cut in the bar plan; default 3.",+                "maximum": 50,+                "minimum": 0,+                "type": "number"+              },+              "mode": {+                "description": "flat: the purchasing list with make/buy and its reason; structured: one row per instance; indented: item numbers and quantity per parent; cutlist: extrusions by profile and length; fasteners: hardware by part number; wires: each cut wire with gauge, color and length; order: bought lines merged by supplier part number.",+                "enum": [+                  "flat",+                  "structured",+                  "indented",+                  "cutlist",+                  "fasteners",+                  "wires",+                  "order"+                ]+              },+              "nativeProperties": {+                "description": "Read part numbers and descriptions (default true; cached per component revision). false gives the structure, quantities and metadata attributes in seconds on a big cloud assembly.",+                "type": "boolean"+              },+              "overwrite": {+                "type": "boolean"+              },+              "physicalTotals": {+                "description": "Sum mass and volume over every body instance (default true). false skips that walk on a big assembly; per-line unit mass is still read.",+                "type": "boolean"+              },+              "stockLengthMm": {+                "description": "Stock bar length for the cut list's bar plan (first-fit decreasing).",+                "exclusiveMinimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename"+            ],+            "type": "object"+          },+          "cad_import": {+            "description": "Import a pre-downloaded local STEP/SAT into a new wrapper component in Hybrid design. Validate optional expected SHA-256, record actual source/hash/supplier metadata, preserve camera, measure model recovery. Does not fetch URLs or create cloud documents. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "asPurchased": {+                "type": "boolean"+              },+              "filename": {+                "type": "string"+              },+              "name": {+                "type": "string"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "provenance": {+                "additionalProperties": false,+                "properties": {+                  "description": {+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  }+                },+                "required": [+                  "supplier",+                  "supplierPartNumber",+                  "sourceUrl"+                ],+                "type": "object"+              },+              "sha256": {+                "type": "string"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename",+              "provenance"+            ],+            "type": "object"+          },+          "cam_inspect": {+            "description": "Read the active document's CAM: setups, their operations' toolpath state, warnings and errors, and NC programs.",+            "properties": {},+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "cam_job": {+            "description": "Make a milling job: a setup on the given bodies, then operations in order (strategy face, adaptive, contour, parallel, scallop, pocket_clearing or drill), each with a tool from Fusion's sample library chosen by type and diameter (nearest) and optional Fusion parameter overrides by name. Drill picks the bodies' holes of the drill's diameter unless holeFaces are given. Generates the toolpaths, reports every operation's warnings and errors and the machining time, and, with post, writes G-code through a post from Fusion's library (FANUC, Grbl, HAAS - Next Generation Control, ...). Opens the Manufacture workspace once if the document has no CAM yet, then returns to the user's workspace. Journaled.",+            "properties": {+              "bodies": {+                "items": {+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "name": {+                "type": "string"+              },+              "operationId": {+                "type": "string"+              },+              "operations": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "holeFaces": {+                      "items": {+                        "type": "object"+                      },+                      "maxItems": 512,+                      "type": "array"+                    },+                    "name": {+                      "type": "string"+                    },+                    "parameters": {+                      "type": "object"+                    },+                    "strategy": {+                      "enum": [+                        "face",+                        "adaptive",+                        "contour",+                        "parallel",+                        "scallop",+                        "pocket_clearing",+                        "drill"+                      ],+                      "type": "string"+                    },+                    "tool": {+                      "additionalProperties": false,+                      "properties": {+                        "diameterMm": {+                          "exclusiveMinimum": 0,+                          "maximum": 200,+                          "type": "number"+                        },+                        "type": {+                          "description": "Tool type as Fusion names it: flat end mill, ball end mill, bull nose end mill, drill, chamfer mill, ...",+                          "type": "string"+                        }+                      },+                      "type": "object"+                    }+                  },+                  "required": [+                    "strategy"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "post": {+                "additionalProperties": false,+                "properties": {+                  "folder": {+                    "type": "string"+                  },+                  "machine": {+                    "type": "string"+                  },+                  "program": {+                    "type": "string"+                  }+                },+                "required": [+                  "folder"+                ],+                "type": "object"+              },+              "timeoutSeconds": {+                "maximum": 3600,+                "minimum": 10,+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "bodies",+              "operations"+            ],+            "type": "object"+          },+          "cam_tools": {+            "description": "List tools in Fusion's sample tool libraries (milling or hole making, metric), optionally of one type, with diameter in mm, so cam_job can name them.",+            "properties": {+              "library": {+                "enum": [+                  "milling",+                  "hole"+                ],+                "type": "string"+              },+              "limit": {+                "maximum": 500,+                "minimum": 1,+                "type": "integer"+              },+              "type": {+                "type": "string"+              }+            },+            "required": [+              "op"+            ],+            "type": "object"+          },+          "component_create": {+            "description": "Create a native internal component and its first occurrence in a Hybrid design. parent is a component definition; edits to it affect every instance. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "metadata": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "asPurchased": {+                    "type": "boolean"+                  },+                  "category": {+                    "description": "e.g. extrusion, fastener, printed, machined, sheet metal, electronics, cable.",+                    "maxLength": 60,+                    "minLength": 1,+                    "type": "string"+                  },+                  "currency": {+                    "description": "ISO 4217 code such as USD.",+                    "type": "string"+                  },+                  "description": {+                    "type": "string"+                  },+                  "excludeFromBom": {+                    "type": "boolean"+                  },+                  "finish": {+                    "maxLength": 120,+                    "type": "string"+                  },+                  "leadTimeDays": {+                    "maximum": 3650,+                    "minimum": 0,+                    "type": "integer"+                  },+                  "makeBuy": {+                    "enum": [+                      "make",+                      "buy"+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "notes": {+                    "maxLength": 2000,+                    "type": "string"+                  },+                  "partNumber": {+                    "type": "string"+                  },+                  "process": {+                    "description": "How a made part is made: 3D print, laser cut, CNC, bent sheet...",+                    "maxLength": 120,+                    "type": "string"+                  },+                  "revision": {+                    "maxLength": 40,+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "stock": {+                    "description": "The stock a linear part is cut from (2020, 4040, 8020-1010...): the cut list groups by it.",+                    "maxLength": 60,+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  },+                  "unitCost": {+                    "minimum": 0,+                    "type": "number"+                  }+                },+                "required": [],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name"+            ],+            "type": "object"+          },+          "component_metadata": {+            "description": "Update component-definition name/part number/description and persistent supplier or BOM attributes. Shared occurrences all see this metadata.",+            "properties": {+              "changes": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "asPurchased": {+                    "type": "boolean"+                  },+                  "category": {+                    "description": "e.g. extrusion, fastener, printed, machined, sheet metal, electronics, cable.",+                    "maxLength": 60,+                    "minLength": 1,+                    "type": "string"+                  },+                  "currency": {+                    "description": "ISO 4217 code such as USD.",+                    "type": "string"+                  },+                  "description": {+                    "type": "string"+                  },+                  "excludeFromBom": {+                    "type": "boolean"+                  },+                  "finish": {+                    "maxLength": 120,+                    "type": "string"+                  },+                  "leadTimeDays": {+                    "maximum": 3650,+                    "minimum": 0,+                    "type": "integer"+                  },+                  "makeBuy": {+                    "enum": [+                      "make",+                      "buy"+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "notes": {+                    "maxLength": 2000,+                    "type": "string"+                  },+                  "partNumber": {+                    "type": "string"+                  },+                  "process": {+                    "description": "How a made part is made: 3D print, laser cut, CNC, bent sheet...",+                    "maxLength": 120,+                    "type": "string"+                  },+                  "revision": {+                    "maxLength": 40,+                    "type": "string"+                  },+                  "sourceUrl": {+                    "type": "string"+                  },+                  "stock": {+                    "description": "The stock a linear part is cut from (2020, 4040, 8020-1010...): the cut list groups by it.",+                    "maxLength": 60,+                    "type": "string"+                  },+                  "supplier": {+                    "type": "string"+                  },+                  "supplierPartNumber": {+                    "type": "string"+                  },+                  "unitCost": {+                    "minimum": 0,+                    "type": "number"+                  }+                },+                "required": [],+                "type": "object"+              },+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "changes"+            ],+            "type": "object"+          },+          "configuration_inspect": {+            "description": "Read the loaded Design configuration graph without activation or recompute: ordinary rows, the separate native reserved test row, all supported typed cells including inactive/test cells, exact controlled-source links and current ordinary row. Unreadable fields and unknown/theme/hierarchical/inserted scopes remain explicit incomplete diagnostics. Configuration lifecycle and configured-design model mutations remain disabled pending native recovery/archive gates.",+            "properties": {},+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "construction_axis": {+            "description": "Create a parametric axis from native references (edge/circular face/two intersecting planes/two distinct points). Root-space external geometry requires exact occurrence context. For cross-component geometry into a non-root target component, creationOccurrence must identify a root-context instance of that target. Returns component-space native axis geometry/health. No direct-only infinite-line or preview snap APIs.",+            "properties": {+              "component": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "creationOccurrence": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "entities": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 2,+                "minItems": 1,+                "type": "array"+              },+              "name": {+                "type": "string"+              },+              "type": {+                "enum": [+                  "edge",+                  "circular_face",+                  "two_planes",+                  "two_points"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "type",+              "entities"+            ],+            "type": "object"+          },+          "efficiency_report": {+            "description": "Read what makes the design slow to recompute, open and edit, held against the efficiency playbook (skills/fusion-design-efficiency): timeline make-up and health, Position snapshots, Move features, size, repeated definitions made by Paste New, instance-weighted faces, imported history, wires in a parametric design, big sketches, pattern compute options, modeled threads, meshes and empty components. Returns metrics and findings (rule, severity, measured, limit, fix). Read-only and needs no revision digest. It is journaled like bom_export, so a long report on a big design is followed with fusion_mech_operation_status after the relay's 60 s; passes past budgetSeconds are skipped and listed, with complete:false.",+            "properties": {+              "budgetSeconds": {+                "description": "Stop the costly passes after this many seconds (default 120).",+                "maximum": 600,+                "minimum": 5,+                "type": "number"+              },+              "computeTiming": {+                "description": "Also time a full computeAll (slow on big designs; default false).",+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "entity_delete": {+            "description": "Delete sketch geometry or independently deletable timeline features. Model transaction and semantic recovery cover downstream failures; document and external file deletion are excluded.",+            "properties": {+              "entity": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "entity"+            ],+            "type": "object"+          },+          "exploded_preview_create": {+            "description": "Create finite copied solid-BRep presentation graphics in the exact active blank unsaved Design proven by a committed current-session new_design result. Regenerates the guarded source plan; leaves source active. Exclusive session lease, no source moves/visibility writes, no model transaction, automatic document close, render or capture. Live capability and native backend qualification are separate from durable operation receipts.",+            "properties": {+              "creationOperationId": {+                "type": "string"+              },+              "expectedPlanId": {+                "type": "string"+              },+              "planner": {+                "additionalProperties": false,+                "properties": {+                  "playback": {+                    "enum": [+                      "explode",+                      "assemble"+                    ],+                    "type": "string"+                  },+                  "sampleTimes": {+                    "items": {+                      "maximum": 3600,+                      "minimum": 0,+                      "type": "number"+                    },+                    "maxItems": 62,+                    "type": "array"+                  },+                  "steps": {+                    "items": {+                      "additionalProperties": false,+                      "properties": {+                        "durationSeconds": {+                          "exclusiveMinimum": 0,+                          "maximum": 3600,+                          "type": "number"+                        },+                        "instruction": {+                          "type": "string"+                        },+                        "moves": {+                          "items": {+                            "additionalProperties": false,+                            "properties": {+                              "direction": {+                                "items": {+                                  "maximum": 1000000000.0,+                                  "minimum": -1000000000.0,+                                  "type": "number"+                                },+                                "maxItems": 3,+                                "minItems": 3,+                                "type": "array"+                              },+                              "distance": {+                                "exclusiveMinimum": 0,+                                "maximum": 1000000.0,+                                "type": "number"+                              },+                              "frame": {+                                "enum": [+                                  "world",+                                  "parent",+                                  "local"+                                ],+                                "type": "string"+                              },+                              "occurrence": {+                                "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                                "type": "object"+                              }+                            },+                            "required": [+                              "occurrence",+                              "direction",+                              "distance",+                              "frame"+                            ],+                            "type": "object"+                          },+                          "maxItems": 128,+                          "minItems": 1,+                          "type": "array"+                        },+                        "title": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "durationSeconds",+                        "moves"+                      ],+                      "type": "object"+                    },+                    "maxItems": 32,+                    "minItems": 1,+                    "type": "array"+                  },+                  "unit": {+                    "enum": [+                      "mm"+                    ],+                    "type": "string"+                  }+                },+                "required": [+                  "unit",+                  "steps"+                ],+                "type": "object"+              },+              "sessionId": {+                "type": "string"+              },+              "sourceTarget": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sourceTarget",+              "creationOperationId",+              "expectedPlanId",+              "planner"+            ],+            "type": "object"+          },+          "exploded_preview_dispose": {+            "description": "Delete only the exact retained graphics tree and leave the blank document open for caller. Supports a narrowly proven cleanup after unresolved terminal storage without rewriting that history; no global Undo or close. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration"+            ],+            "type": "object"+          },+          "exploded_preview_inspect": {+            "description": "Main-thread live preview ownership/geometry/history observation. Cached operation receipts do not establish current graphics liveness. Old-session history remains separately readable through mech_operation_status; no native reference adoption or lifecycle repair is provided here.",+            "properties": {+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "previewId"+            ],+            "type": "object"+          },+          "exploded_preview_sample": {+            "description": "Apply one server-stored absolute sample to exact-owned graphics; preserve active document. Source must remain unchanged. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sampleIndex": {+                "maximum": 63,+                "minimum": 0,+                "type": "integer"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration",+              "sampleIndex"+            ],+            "type": "object"+          },+          "exploded_preview_show": {+            "description": "Explicitly activate the exact-owned presentation in Fusion; refuse an intervening foreign active document. No OS foreground, camera change or capture. Requires the current controller capability, presentation target, generation and a durable operation ID. Old-session native resources are never rebound.",+            "properties": {+              "expectedGeneration": {+                "maximum": 1000000000,+                "minimum": 0,+                "type": "integer"+              },+              "previewId": {+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "previewId",+              "expectedGeneration"+            ],+            "type": "object"+          },+          "exploded_view_plan": {+            "description": "Read-only source-bound exploded assembly plan. Normalized translation directions in immutable home world/parent/local axes; simultaneous moves within ordered steps. Descendants inherit ancestor translations once, plus own moves. Bounded deterministic sample matrices and exact home reverse endpoint. No native moves, graphics, BOM quantity changes, render/video or storyboard creation. Complete configuration identity required.",+            "properties": {+              "playback": {+                "enum": [+                  "explode",+                  "assemble"+                ],+                "type": "string"+              },+              "sampleTimes": {+                "items": {+                  "maximum": 3600,+                  "minimum": 0,+                  "type": "number"+                },+                "maxItems": 62,+                "type": "array"+              },+              "sessionId": {+                "type": "string"+              },+              "steps": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "durationSeconds": {+                      "exclusiveMinimum": 0,+                      "maximum": 3600,+                      "type": "number"+                    },+                    "instruction": {+                      "type": "string"+                    },+                    "moves": {+                      "items": {+                        "additionalProperties": false,+                        "properties": {+                          "direction": {+                            "items": {+                              "maximum": 1000000000.0,+                              "minimum": -1000000000.0,+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 3,+                            "type": "array"+                          },+                          "distance": {+                            "exclusiveMinimum": 0,+                            "maximum": 1000000.0,+                            "type": "number"+                          },+                          "frame": {+                            "enum": [+                              "world",+                              "parent",+                              "local"+                            ],+                            "type": "string"+                          },+                          "occurrence": {+                            "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                            "type": "object"+                          }+                        },+                        "required": [+                          "occurrence",+                          "direction",+                          "distance",+                          "frame"+                        ],+                        "type": "object"+                      },+                      "maxItems": 128,+                      "minItems": 1,+                      "type": "array"+                    },+                    "title": {+                      "type": "string"+                    }+                  },+                  "required": [+                    "durationSeconds",+                    "moves"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "unit": {+                "enum": [+                  "mm"+                ],+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "target",+              "unit",+              "steps"+            ],+            "type": "object"+          },+          "exploded_view_render": {+            "description": "Render an exploded-view animation for operators: play the same steps as exploded_view_plan on the real occurrences, save one viewport image per frame from a fixed camera (fitted to the most exploded state), then revert every move and verify each instance is back home and the document state unchanged. Refuses a design with an uncaptured move. Journaled; follow a long render with fusion_mech_operation_status. Returns the frame folder, timed captions from the steps' titles and instructions, and the ffmpeg line that joins the frames into MP4 (Fusion's API has no video export).",+            "properties": {+              "fit": {+                "description": "Fit the camera to the most exploded state first (default true); false keeps the current view.",+                "type": "boolean"+              },+              "folder": {+                "description": "Absolute folder on the PC for frame_00000.png ... (created if missing).",+                "type": "string"+              },+              "fps": {+                "description": "Frames per second (default 24).",+                "maximum": 60,+                "minimum": 1,+                "type": "integer"+              },+              "height": {+                "description": "Frame height in pixels (default 720).",+                "maximum": 2160,+                "minimum": 240,+                "type": "integer"+              },+              "holdSeconds": {+                "description": "Hold the last pose this long (default 1).",+                "maximum": 30,+                "minimum": 0,+                "type": "number"+              },+              "operationId": {+                "type": "string"+              },+              "overwrite": {+                "description": "Replace frames already in folder (default false).",+                "type": "boolean"+              },+              "playback": {+                "enum": [+                  "explode",+                  "assemble"+                ],+                "type": "string"+              },+              "sessionId": {+                "type": "string"+              },+              "steps": {+                "items": {+                  "additionalProperties": false,+                  "properties": {+                    "durationSeconds": {+                      "exclusiveMinimum": 0,+                      "maximum": 3600,+                      "type": "number"+                    },+                    "instruction": {+                      "type": "string"+                    },+                    "moves": {+                      "items": {+                        "additionalProperties": false,+                        "properties": {+                          "direction": {+                            "items": {+                              "maximum": 1000000000.0,+                              "minimum": -1000000000.0,+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 3,+                            "type": "array"+                          },+                          "distance": {+                            "exclusiveMinimum": 0,+                            "maximum": 1000000.0,+                            "type": "number"+                          },+                          "frame": {+                            "enum": [+                              "world",+                              "parent",+                              "local"+                            ],+                            "type": "string"+                          },+                          "occurrence": {+                            "description": "Exact guarded occurrence reference from inspect; every repeated/nested instance is distinct.",+                            "type": "object"+                          }+                        },+                        "required": [+                          "occurrence",+                          "direction",+                          "distance",+                          "frame"+                        ],+                        "type": "object"+                      },+                      "maxItems": 128,+                      "minItems": 1,+                      "type": "array"+                    },+                    "title": {+                      "type": "string"+                    }+                  },+                  "required": [+                    "durationSeconds",+                    "moves"+                  ],+                  "type": "object"+                },+                "maxItems": 32,+                "minItems": 1,+                "type": "array"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              },+              "unit": {+                "enum": [+                  "mm"+                ],+                "type": "string"+              },+              "width": {+                "description": "Frame width in pixels (default 1280).",+                "maximum": 3840,+                "minimum": 320,+                "type": "integer"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "unit",+              "steps",+              "folder"+            ],+            "type": "object"+          },+          "export": {+            "description": "Export entire design using runtime-checked API. Preflight and unique same-filesystem staging preserve the destination on failure; publish only nonempty verified output. Availability differs by Fusion build. STL numeric coordinates use mm.",+            "properties": {+              "format": {+                "default": "step",+                "enum": [+                  "step",+                  "stl",+                  "3mf",+                  "f3d",+                  "iges",+                  "sat",+                  "smt",+                  "usdz",+                  "fbx",+                  "skp"+                ]+              },+              "outputPath": {+                "type": "string"+              },+              "overwrite": {+                "default": false,+                "type": "boolean"+              },+              "refinement": {+                "default": "medium",+                "enum": [+                  "low",+                  "medium",+                  "high"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "outputPath"+            ],+            "type": "object"+          },+          "feature_create": {+            "description": "Create a typed native solid feature. All length quantities are mm (or expressions), angles deg. Cut/intersect require explicit participant bodies. Join needs a single existing component body; combine selects multiple bodies explicitly. Feature availability is runtime-checked; missing APIs fail before commit. Rectangular and circular patterns repeat exactly one of bodies, features, faces or occurrences (a component pattern, built in the occurrences' shared parent so the part stays one definition); computeOption is identical (default), optimized or adjust and does not apply to component patterns.",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "direction": {+                    "enum": [+                      "positive",+                      "negative",+                      "symmetric"+                    ]+                  },+                  "distance": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "taper": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "extrude"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "distance"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "revolve"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "axis",+                  "angle"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "edges": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "radius": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "fillet"+                    ]+                  }+                },+                "required": [+                  "type",+                  "edges",+                  "radius"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "distance": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "edges": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "chamfer"+                    ]+                  }+                },+                "required": [+                  "type",+                  "edges",+                  "distance"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "thickness": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "type": {+                    "enum": [+                      "shell"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "thickness"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "depth": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "diameter": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "points": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "hole"+                    ]+                  }+                },+                "required": [+                  "type",+                  "points",+                  "diameter",+                  "depth",+                  "bodies"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "loft"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "new_body",+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "path": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "profiles": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "sweep"+                    ]+                  }+                },+                "required": [+                  "type",+                  "profiles",+                  "path"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "body": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keepTools": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operation": {+                    "enum": [+                      "join",+                      "cut",+                      "intersect"+                    ]+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "tools": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "type": {+                    "enum": [+                      "combine"+                    ]+                  }+                },+                "required": [+                  "type",+                  "body",+                  "tools",+                  "operation"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "extend": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "split"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies",+                  "plane"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "origin": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "translation": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "type": {+                    "enum": [+                      "move"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "mirror"+                    ]+                  }+                },+                "required": [+                  "type",+                  "bodies",+                  "plane"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "axis2": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "computeOption": {+                    "description": "identical (default) repeats the first result; optimized is fastest but can drop instances that touch other geometry; adjust recomputes every instance (slowest). Ignored for occurrences.",+                    "enum": [+                      "identical",+                      "optimized",+                      "adjust"+                    ]+                  },+                  "count": {+                    "maximum": 1000,+                    "minimum": 2,+                    "type": "integer"+                  },+                  "count2": {+                    "maximum": 1000,+                    "minimum": 1,+                    "type": "integer"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "features": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrences": {+                    "items": {+                      "description": "Occurrence reference returned by inspect in this document revision; all must share one parent component, where the component pattern is built.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "spacing": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "spacing2": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "rectangular_pattern"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "count",+                  "spacing"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "bodies": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "computeOption": {+                    "description": "identical (default) repeats the first result; optimized is fastest but can drop instances that touch other geometry; adjust recomputes every instance (slowest). Ignored for occurrences.",+                    "enum": [+                      "identical",+                      "optimized",+                      "adjust"+                    ]+                  },+                  "count": {+                    "maximum": 1000,+                    "minimum": 2,+                    "type": "integer"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "features": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrences": {+                    "items": {+                      "description": "Occurrence reference returned by inspect in this document revision; all must share one parent component, where the component pattern is built.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "circular_pattern"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "count"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "tangentChain": {+                    "type": "boolean"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "draft"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "plane",+                  "angle"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "designation": {+                    "type": "string"+                  },+                  "faces": {+                    "items": {+                      "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                      "required": [+                        "documentId",+                        "revision",+                        "objectType"+                      ],+                      "type": "object"+                    },+                    "maxItems": 256,+                    "minItems": 1,+                    "type": "array"+                  },+                  "internal": {+                    "type": "boolean"+                  },+                  "modeled": {+                    "type": "boolean"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "additionalProperties": false,+                    "properties": {+                      "documentId": {+                        "type": "string"+                      },+                      "revision": {+                        "type": "string"+                      }+                    },+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "threadClass": {+                    "type": "string"+                  },+                  "threadType": {+                    "type": "string"+                  },+                  "type": {+                    "enum": [+                      "thread"+                    ]+                  }+                },+                "required": [+                  "type",+                  "faces",+                  "internal",+                  "threadType",+                  "designation",+                  "threadClass"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "angle": {},+              "axis": {},+              "axis2": {},+              "bodies": {},+              "body": {},+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "computeOption": {},+              "count": {},+              "count2": {},+              "depth": {},+              "designation": {},+              "diameter": {},+              "direction": {},+              "distance": {},+              "edges": {},+              "extend": {},+              "faces": {},+              "features": {},+              "internal": {},+              "keepTools": {},+              "modeled": {},+              "name": {+                "type": "string"+              },+              "occurrences": {},+              "operation": {},+              "origin": {},+              "path": {},+              "plane": {},+              "points": {},+              "profiles": {},+              "radius": {},+              "spacing": {},+              "spacing2": {},+              "tangentChain": {},+              "taper": {},+              "thickness": {},+              "threadClass": {},+              "threadType": {},+              "tools": {},+              "translation": {},+              "type": {+                "enum": [+                  "extrude",+                  "revolve",+                  "fillet",+                  "chamfer",+                  "shell",+                  "hole",+                  "loft",+                  "sweep",+                  "combine",+                  "split",+                  "move",+                  "mirror",+                  "rectangular_pattern",+                  "circular_pattern",+                  "draft",+                  "thread"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type"+            ],+            "type": "object"+          },+          "feature_edit": {+            "description": "Rename/suppress a feature or change expressions of model parameters whose createdBy is that exact feature; read health and abort on downstream errors.",+            "properties": {+              "feature": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "parameters": {+                "additionalProperties": {+                  "type": "string"+                },+                "type": "object"+              },+              "suppressed": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "feature"+            ],+            "type": "object"+          },+          "geometry_query": {+            "description": "Complete body-scoped topology query, no arbitrary first-match selection. selection one (default) refuses zero/multiple matches; many may return empty. Geometry types are exact native types; size ranges inclusive in mm/mm2, near is minimum distance in the explicit frame; direction is outward planar face normal or linear edge tangent. Returned refs retain instance context even for component-space filters. Exceeding maxResults fails rather than truncating.",+            "properties": {+              "body": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "filters": {+                "additionalProperties": false,+                "properties": {+                  "area": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "direction": {+                    "additionalProperties": false,+                    "properties": {+                      "orientation": {+                        "enum": [+                          "same",+                          "parallel"+                        ]+                      },+                      "tolerance": {+                        "maximum": 90,+                        "minimum": 0,+                        "type": "number"+                      },+                      "vector": {+                        "items": {+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "vector"+                    ],+                    "type": "object"+                  },+                  "length": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "near": {+                    "additionalProperties": false,+                    "properties": {+                      "point": {+                        "items": {+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "tolerance": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [+                      "point",+                      "tolerance"+                    ],+                    "type": "object"+                  },+                  "radius": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "max": {+                        "minimum": 0,+                        "type": "number"+                      },+                      "min": {+                        "minimum": 0,+                        "type": "number"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "Plane",+                      "Cylinder",+                      "Cone",+                      "Sphere",+                      "Torus",+                      "NurbsSurface",+                      "Line3D",+                      "Arc3D",+                      "Circle3D",+                      "Ellipse3D",+                      "EllipticalArc3D",+                      "NurbsCurve3D",+                      "Point3D",+                      "degenerate"+                    ]+                  }+                },+                "required": [],+                "type": "object"+              },+              "kind": {+                "enum": [+                  "faces",+                  "edges",+                  "vertices"+                ]+              },+              "maxResults": {+                "maximum": 1024,+                "minimum": 1,+                "type": "integer"+              },+              "selection": {+                "enum": [+                  "one",+                  "many"+                ]+              },+              "space": {+                "enum": [+                  "root",+                  "component"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "body",+              "kind",+              "space"+            ],+            "type": "object"+          },+          "health": {+            "description": "Read timeline warnings/errors. recompute:true also requires current target revision, sessionId and operationId.",+            "properties": {+              "recompute": {+                "default": false,+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "inspect": {+            "description": "Inspect the active Design without mutation. Returns target identity/revision, native component-space bodies and occurrence transforms, parameters and feature health.",+            "properties": {+              "bodyMetrics": {+                "description": "Read each body's physical properties and bounding box (about 10 ms a body). Default: true for designs of 200 components or fewer.",+                "type": "boolean"+              },+              "componentProperties": {+                "description": "Read each component's part number and description (cloud reads, about 0.6 s each per component on a cloud document). Default: true for 200 components or fewer.",+                "type": "boolean"+              },+              "detail": {+                "description": "target: only the target, document and counts (what a write or a BOM needs), for an assembly too big for a full inspect inside the relay's budget. Default full.",+                "enum": [+                  "full",+                  "target"+                ]+              },+              "health": {+                "description": "Read timeline health (about 22 ms a timeline item). Default: true for timelines of 200 items or fewer; otherwise use op health.",+                "type": "boolean"+              }+            },+            "required": [+              "op"+            ],+            "type": "object"+          },+          "inspect_entity": {+            "properties": {+              "entity": {+                "description": "Exact reference returned by inspect; resolves uniquely with document/revision/type/occurrence guards.",+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "entity"+            ],+            "type": "object"+          },+          "interference": {+            "description": "Analyze root-context occurrences/body proxies; returns overlap volume mm3 or touching. Does not create interference bodies.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 2,+                "type": "array"+              },+              "includeTouching": {+                "type": "boolean"+              },+              "volumeTolerance": {+                "minimum": 0,+                "type": "number"+              }+            },+            "required": [+              "op",+              "target",+              "entities"+            ],+            "type": "object"+          },+          "joint_create": {+            "description": "Create an as-built joint without moving occurrences. Non-rigid motion requires explicit joint geometry; x/y/z are joint-coordinate directions. Limits and drive values use mm/deg. Seven native motion types; ball uses joint Z pitch/X yaw; planar uses native primary slide direction reported on readback. Use regular_joint_create for geometry-solving placement.",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "rigid"+                    ]+                  }+                },+                "required": [+                  "type"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "revolute"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "slider"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "cylindrical"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "slideAxis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "slideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "slideValue": {+                    "type": "number"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "pin_slot"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "axis": {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "primarySlideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "primarySlideValue": {+                    "type": "number"+                  },+                  "rotationLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rotationValue": {+                    "type": "number"+                  },+                  "secondarySlideLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "secondarySlideValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "planar"+                    ]+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "geometry": {+                    "additionalProperties": false,+                    "properties": {+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "occurrenceOne": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "occurrenceTwo": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "pitchLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "pitchValue": {+                    "type": "number"+                  },+                  "rollLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "rollValue": {+                    "type": "number"+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "suppressed": {+                    "type": "boolean"+                  },+                  "target": {+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "ball"+                    ]+                  },+                  "yawLimits": {+                    "additionalProperties": false,+                    "minProperties": 1,+                    "properties": {+                      "maximum": {+                        "type": "number"+                      },+                      "maximumEnabled": {+                        "type": "boolean"+                      },+                      "minimum": {+                        "type": "number"+                      },+                      "minimumEnabled": {+                        "type": "boolean"+                      },+                      "rest": {+                        "type": "number"+                      },+                      "restEnabled": {+                        "type": "boolean"+                      }+                    },+                    "required": [],+                    "type": "object"+                  },+                  "yawValue": {+                    "type": "number"+                  }+                },+                "required": [+                  "type",+                  "geometry"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "occurrenceOne": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "occurrenceTwo": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "suppressed": {+                "type": "boolean"+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type",+              "occurrenceOne",+              "occurrenceTwo"+            ],+            "type": "object"+          },+          "joint_delete": {+            "description": "Delete one selected Joint or AsBuiltJoint with recovery verification.",+            "properties": {+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "joint_edit": {+            "description": "Edit joint name/suppression, enabled limits, rest and drive values; wrong motion type or out-of-limit values fail with recovery. For driven root joints, active motion links must preserve their settings and their partner motion must follow the native ratio; a coupling mismatch aborts.",+            "properties": {+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "suppressed": {+                "type": "boolean"+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "joint_origin_create": {+            "description": "Create a native component-definition joint origin from guarded native geometry, with mm offsets/deg angle and optional straight axis references. Child occurrence origin references are exposed by inspect_entity(occurrence).",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "flipped": {+                "type": "boolean"+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "edge": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetZ": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "xAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "zAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "geometry"+            ],+            "type": "object"+          },+          "joint_origin_delete": {+            "description": "Delete a native joint origin; unhealthy downstream joints cause transaction rollback.",+            "properties": {+              "origin": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "origin"+            ],+            "type": "object"+          },+          "joint_origin_edit": {+            "description": "Edit a native joint origin definition; rolls before its timeline item and restores the original marker in finally. Recomputes and verifies attachment, axes, offsets, angle, name and flip.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometry": {+                "additionalProperties": false,+                "properties": {+                  "edge": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "entity": {+                    "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "keyPoint": {+                    "enum": [+                      "center",+                      "start",+                      "middle",+                      "end"+                    ]+                  }+                },+                "required": [+                  "entity"+                ],+                "type": "object"+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetZ": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "origin": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "xAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "zAxisEntity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "origin"+            ],+            "type": "object"+          },+          "material_assign": {+            "description": "Assign a loaded library or document material to an exact native Component/BRepBody; verify material ID readback with model transaction recovery. Query assembly_properties for resulting mass.",+            "properties": {+              "entity": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "libraryId": {+                "type": "string"+              },+              "materialId": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "entity",+              "materialId"+            ],+            "type": "object"+          },+          "material_list": {+            "description": "List loaded material libraries and matching materials by stable library/material IDs. Omit libraryId to search the document's materials and then every loaded library; each row names the libraryId material_assign needs (null for the document's own).",+            "properties": {+              "libraryId": {+                "type": "string"+              },+              "limit": {+                "maximum": 1000,+                "minimum": 1,+                "type": "integer"+              },+              "query": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "target"+            ],+            "type": "object"+          },+          "mcmaster_discover": {+            "description": "Discover Fusion native Insert McMaster-Carr command and requirements in the active design.",+            "properties": {},+            "required": [+              "op"+            ],+            "type": "object"+          },+          "mcmaster_open": {+            "description": "Invoke Fusion native McMaster UI in the targeted Hybrid design. Interactive external operation: completion/insert/cancel stays with Fusion; inspect afterward. Idempotency records launch only.",+            "properties": {},+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "measure": {+            "description": "Native engineering minimum distance or angle in root assembly space. Non-root definition refs require an occurrence context. Distance needs2 entities; angle needs2 lines/planes or3 points (second apex). Returns mm/deg and native witness positions in root mm. witnessValidation identifies native points or native geometry directions used for valid parallel angles with degenerate native points; degenerate point angles and unavailable/inconsistent witnesses fail.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "space": {+                "enum": [+                  "root"+                ]+              },+              "type": {+                "enum": [+                  "distance",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "target",+              "type",+              "space",+              "entities"+            ],+            "type": "object"+          },+          "motion_link_create": {+            "description": "Create a native motion link between two root-owned joints, or two different motions of jointOne when jointTwo is omitted. Positive ratio magnitudes use mm for translation and deg for rotation; reversed selects opposite direction. Requires the November 2025+ API; no script fallback.",+            "properties": {+              "jointOne": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "jointTwo": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "motionOne": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "motionTwo": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "reversed": {+                "type": "boolean"+              },+              "valueOne": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "valueTwo": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "jointOne",+              "motionOne",+              "motionTwo",+              "valueOne",+              "valueTwo"+            ],+            "type": "object"+          },+          "motion_link_delete": {+            "description": "Delete a root-owned motion link under the same transaction/recovery contract.",+            "properties": {+              "link": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "link"+            ],+            "type": "object"+          },+          "motion_link_edit": {+            "description": "Edit a root-owned motion link ratio, degree-of-freedom pair, direction, name or suppression. Joint membership is immutable; recreate the link to change members. Verify exact joint identities, ratio, flags and health.",+            "properties": {+              "link": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "motionOne": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "motionTwo": {+                "enum": [+                  "rotation",+                  "slide",+                  "primarySlide",+                  "secondarySlide",+                  "pitch",+                  "roll",+                  "yaw"+                ]+              },+              "name": {+                "maxLength": 120,+                "minLength": 1,+                "type": "string"+              },+              "reversed": {+                "type": "boolean"+              },+              "suppressed": {+                "type": "boolean"+              },+              "valueOne": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "valueTwo": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "link"+            ],+            "type": "object"+          },+          "new_design": {+            "description": "Create an unnamed unsaved parametric hybrid Design; name is retained as requestedName metadata to keep failure recovery free of save dialogs. Optional box dimensions in mm create a driving-parameter fixture. Never edits an existing document.",+            "properties": {+              "box": {+                "additionalProperties": false,+                "properties": {+                  "depth": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  },+                  "height": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  },+                  "width": {+                    "exclusiveMinimum": 0,+                    "type": "number"+                  }+                },+                "required": [+                  "width",+                  "height",+                  "depth"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId"+            ],+            "type": "object"+          },+          "occurrence_delete": {+            "description": "Delete one selected occurrence through the shared transaction executor.",+            "properties": {+              "occurrence": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "occurrence"+            ],+            "type": "object"+          },+          "occurrence_insert": {+            "description": "Insert another occurrence of an existing definition; independentCopy:true uses Paste New to create a separate definition. Nested placement is in parent component coordinates. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused.",+            "properties": {+              "component": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "independentCopy": {+                "type": "boolean"+              },+              "parent": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "component"+            ],+            "type": "object"+          },+          "occurrence_update": {+            "description": "Set occurrence pose in its assembly context and capture position; explicit grounding/ungrounding. Grounded or constrained transforms fail with recovery.",+            "properties": {+              "grounded": {+                "type": "boolean"+              },+              "groundedToParent": {+                "type": "boolean"+              },+              "method": {+                "description": "How a new transform is kept. auto (default): edit the occurrence's initial position when Fusion allows it (a root-level occurrence without joints or patterns), which adds nothing to the timeline, else capture a Position snapshot. initial_position: refuse rather than capture. capture: always capture a snapshot. The reply's placement says which was used.",+                "enum": [+                  "auto",+                  "initial_position",+                  "capture"+                ],+                "type": "string"+              },+              "occurrence": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "transform": {+                "additionalProperties": false,+                "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context.",+                "properties": {+                  "angle": {+                    "type": "number"+                  },+                  "axis": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 3,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "occurrence"+            ],+            "type": "object"+          },+          "parameter_batch": {+            "description": "Atomic sequential create/set/delete parameter edits with one recompute+health gate; delete supports user parameters only. Any failure aborts all edits and reports semantic recovery.",+            "properties": {+              "changes": {+                "items": {+                  "oneOf": [+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "create"+                          ]+                        },+                        "comment": {+                          "type": "string"+                        },+                        "expression": {+                          "type": "string"+                        },+                        "name": {+                          "type": "string"+                        },+                        "unit": {+                          "enum": [+                            "mm",+                            "deg",+                            "kg",+                            ""+                          ]+                        }+                      },+                      "required": [+                        "action",+                        "name",+                        "expression",+                        "unit"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "set"+                          ]+                        },+                        "expression": {+                          "type": "string"+                        },+                        "name": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "action",+                        "name",+                        "expression"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "action": {+                          "enum": [+                            "delete"+                          ]+                        },+                        "name": {+                          "type": "string"+                        }+                      },+                      "required": [+                        "action",+                        "name"+                      ],+                      "type": "object"+                    }+                  ]+                },+                "maxItems": 128,+                "minItems": 1,+                "type": "array"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "changes"+            ],+            "type": "object"+          },+          "parameter_create": {+            "properties": {+              "comment": {+                "type": "string"+              },+              "expression": {+                "type": "string"+              },+              "name": {+                "type": "string"+              },+              "unit": {+                "enum": [+                  "mm",+                  "deg",+                  "kg",+                  ""+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name",+              "expression",+              "unit"+            ],+            "type": "object"+          },+          "parameter_set": {+            "description": "Set an expression, recompute and inspect health. Failure restores old expression and reports a semantic recovery witness; not an atomic transaction.",+            "properties": {+              "expression": {+                "type": "string"+              },+              "name": {+                "type": "string"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "name",+              "expression"+            ],+            "type": "object"+          },+          "plane_create": {+            "description": "Create offset plane (offset in mm) or angled plane around axis (angle in deg).",+            "oneOf": [+              {+                "additionalProperties": false,+                "properties": {+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "offset": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "offset"+                    ]+                  }+                },+                "required": [+                  "type",+                  "offset"+                ],+                "type": "object"+              },+              {+                "additionalProperties": false,+                "properties": {+                  "angle": {+                    "oneOf": [+                      {+                        "type": "number"+                      },+                      {+                        "type": "string"+                      }+                    ]+                  },+                  "axis": {+                    "oneOf": [+                      {+                        "enum": [+                          "x",+                          "y",+                          "z"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "component": {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  },+                  "name": {+                    "type": "string"+                  },+                  "op": {+                    "type": "string"+                  },+                  "operationId": {+                    "type": "string"+                  },+                  "plane": {+                    "oneOf": [+                      {+                        "enum": [+                          "xy",+                          "xz",+                          "yz"+                        ]+                      },+                      {+                        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    ]+                  },+                  "sessionId": {+                    "type": "string"+                  },+                  "target": {+                    "required": [+                      "documentId",+                      "revision"+                    ],+                    "type": "object"+                  },+                  "type": {+                    "enum": [+                      "angle"+                    ]+                  }+                },+                "required": [+                  "type",+                  "axis",+                  "angle"+                ],+                "type": "object"+              }+            ],+            "properties": {+              "angle": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "oneOf": [+                  {+                    "enum": [+                      "x",+                      "y",+                      "z"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              },+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "offset": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "plane": {+                "oneOf": [+                  {+                    "enum": [+                      "xy",+                      "xz",+                      "yz"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              },+              "type": {+                "enum": [+                  "offset",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type"+            ],+            "type": "object"+          },+          "regular_joint_create": {+            "description": "Create a geometry-solving regular joint in the root component using two distinct instance-context attachments or joint origins. All seven native motion families; offsets mm, angle and angular limits deg. Read back freshly resolved attachment graph, native parameters and root-space occurrence placement. Root/non-root sides must be unambiguous; both grounded and ancestor/descendant pairs are refused. Inferred joints are unsupported. Existing pending positions must be captured or reverted first. Before applying drive values, checks native joint-transform anchor offset magnitude/axiality and zero-angle axis collinearity. Native joint matrices have explicit provenance; physical angle/flip sense requires independent occurrence-geometry acceptance.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometryOne": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "geometryTwo": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "locked": {+                "type": "boolean"+              },+              "name": {+                "type": "string"+              },+              "offset": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "pitchLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "pitchValue": {+                "type": "number"+              },+              "primarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "primarySlideValue": {+                "type": "number"+              },+              "rollLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rollValue": {+                "type": "number"+              },+              "rotationLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "rotationValue": {+                "type": "number"+              },+              "secondarySlideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "secondarySlideValue": {+                "type": "number"+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "slideLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "slideValue": {+                "type": "number"+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              },+              "yawLimits": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "maximum": {+                    "type": "number"+                  },+                  "maximumEnabled": {+                    "type": "boolean"+                  },+                  "minimum": {+                    "type": "number"+                  },+                  "minimumEnabled": {+                    "type": "boolean"+                  },+                  "rest": {+                    "type": "number"+                  },+                  "restEnabled": {+                    "type": "boolean"+                  }+                },+                "required": [],+                "type": "object"+              },+              "yawValue": {+                "type": "number"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "type",+              "geometryOne",+              "geometryTwo"+            ],+            "type": "object"+          },+          "regular_joint_edit": {+            "description": "Redefine root-owned regular joint geometry, motion family, offsets, angle, flip or lock. Restore timeline in finally and verify after recompute. Use joint_edit for name, suppression, limits and drive values; joint_delete for deletion.",+            "properties": {+              "angle": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "axis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "flipped": {+                "type": "boolean"+              },+              "geometryOne": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "geometryTwo": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "edge": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "entity": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      },+                      "keyPoint": {+                        "enum": [+                          "center",+                          "start",+                          "middle",+                          "end"+                        ]+                      }+                    },+                    "required": [+                      "entity"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "origin": {+                        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                        "required": [+                          "documentId",+                          "revision",+                          "objectType"+                        ],+                        "type": "object"+                      }+                    },+                    "required": [+                      "origin"+                    ],+                    "type": "object"+                  }+                ]+              },+              "joint": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "locked": {+                "type": "boolean"+              },+              "offset": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetX": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "offsetY": {+                "description": "Number in mm (angle in deg), or a dimensionally valid Fusion parameter expression.",+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "maxLength": 512,+                    "minLength": 1,+                    "type": "string"+                  }+                ]+              },+              "slideAxis": {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              "type": {+                "enum": [+                  "rigid",+                  "revolute",+                  "slider",+                  "cylindrical",+                  "pin_slot",+                  "planar",+                  "ball"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "joint"+            ],+            "type": "object"+          },+          "render_image": {+            "description": "Render a photoreal image with Fusion's local renderer: from a standard view fitted to the design (iso by default) or the current view, at a size and quality (0 to 100; 75 by default), optionally on a transparent background or without the ground. Waits for the render, then restores the camera and every render setting it changed. Journaled: a large, high-quality render runs for minutes, so follow it with fusion_mech_operation_status. Fusion's API cannot choose the render environment; the document's own is used.",+            "properties": {+              "filename": {+                "description": "Absolute .png or .jpg path on the PC.",+                "type": "string"+              },+              "ground": {+                "description": "Show the ground plane (shadows and reflections); default leaves the document's setting.",+                "type": "boolean"+              },+              "height": {+                "maximum": 4320,+                "minimum": 64,+                "type": "integer"+              },+              "operationId": {+                "type": "string"+              },+              "overwrite": {+                "type": "boolean"+              },+              "quality": {+                "maximum": 100,+                "minimum": 0,+                "type": "integer"+              },+              "timeoutSeconds": {+                "maximum": 3600,+                "minimum": 10,+                "type": "number"+              },+              "transparent": {+                "type": "boolean"+              },+              "view": {+                "enum": [+                  "iso",+                  "iso-left",+                  "front",+                  "back",+                  "top",+                  "bottom",+                  "left",+                  "right",+                  "current"+                ],+                "type": "string"+              },+              "width": {+                "maximum": 7680,+                "minimum": 64,+                "type": "integer"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "filename"+            ],+            "type": "object"+          },+          "render_scene_inspect": {+            "description": "Guarded main-thread read of current viewport camera, render settings and up to 32 environments. Optional detached world-mm camera is constructed and read back without viewport assignment. Missing fields return PARTIAL; observationComplete covers only bounded available scope. sceneWitnessComplete and renderQualified remain false. No rendering, workspace activation or scene writes.",+            "properties": {+              "camera": {+                "oneOf": [+                  {+                    "additionalProperties": false,+                    "properties": {+                      "extents": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": 1e-06,+                          "type": "number"+                        },+                        "maxItems": 2,+                        "minItems": 2,+                        "type": "array"+                      },+                      "eye": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "space": {+                        "enum": [+                          "world"+                        ],+                        "type": "string"+                      },+                      "target": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "type": {+                        "enum": [+                          "orthographic"+                        ],+                        "type": "string"+                      },+                      "unit": {+                        "enum": [+                          "mm"+                        ],+                        "type": "string"+                      },+                      "upVector": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "type",+                      "space",+                      "unit",+                      "eye",+                      "target",+                      "upVector",+                      "extents"+                    ],+                    "type": "object"+                  },+                  {+                    "additionalProperties": false,+                    "properties": {+                      "angleUnit": {+                        "enum": [+                          "deg"+                        ],+                        "type": "string"+                      },+                      "eye": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "perspectiveAngle": {+                        "exclusiveMinimum": 0,+                        "maximum": 179.999999999,+                        "type": "number"+                      },+                      "space": {+                        "enum": [+                          "world"+                        ],+                        "type": "string"+                      },+                      "target": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      },+                      "type": {+                        "enum": [+                          "perspective"+                        ],+                        "type": "string"+                      },+                      "unit": {+                        "enum": [+                          "mm"+                        ],+                        "type": "string"+                      },+                      "upVector": {+                        "items": {+                          "maximum": 1000000000.0,+                          "minimum": -1000000000.0,+                          "type": "number"+                        },+                        "maxItems": 3,+                        "minItems": 3,+                        "type": "array"+                      }+                    },+                    "required": [+                      "type",+                      "space",+                      "unit",+                      "eye",+                      "target",+                      "upVector",+                      "perspectiveAngle",+                      "angleUnit"+                    ],+                    "type": "object"+                  }+                ]+              },+              "maxEnvironments": {+                "maximum": 32,+                "minimum": 0,+                "type": "integer"+              },+              "sessionId": {+                "type": "string"+              },+              "target": {+                "additionalProperties": false,+                "properties": {+                  "documentId": {+                    "type": "string"+                  },+                  "revision": {+                    "type": "string"+                  }+                },+                "required": [+                  "documentId",+                  "revision"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "target"+            ],+            "type": "object"+          },+          "rigid_group_create": {+            "description": "Create a native rigid group from exact occurrence instances; includeChildren defaults true.",+            "properties": {+              "includeChildren": {+                "type": "boolean"+              },+              "name": {+                "type": "string"+              },+              "occurrences": {+                "items": {+                  "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 2,+                "type": "array"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "occurrences"+            ],+            "type": "object"+          },+          "rigid_group_delete": {+            "description": "Delete an exact rigid group with transaction recovery.",+            "properties": {+              "group": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "group"+            ],+            "type": "object"+          },+          "rigid_group_edit": {+            "description": "Rename or suppress an exact rigid group with transaction recovery.",+            "properties": {+              "group": {+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "suppressed": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "group"+            ],+            "type": "object"+          },+          "sketch_constraint": {+            "description": "Constrain entities in one sketch. midpoint order is point,line; symmetry order entity1,entity2,symmetryLine. fix sets one entity fixed.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "type": {+                "enum": [+                  "horizontal",+                  "vertical",+                  "coincident",+                  "parallel",+                  "perpendicular",+                  "tangent",+                  "equal",+                  "concentric",+                  "collinear",+                  "midpoint",+                  "symmetry",+                  "fix"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "type",+              "entities"+            ],+            "type": "object"+          },+          "sketch_create": {+            "description": "Create a native component-definition sketch on an origin/construction plane or planar face. Coordinates in subsequent geometry are sketch-space mm.",+            "properties": {+              "component": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "name": {+                "type": "string"+              },+              "plane": {+                "oneOf": [+                  {+                    "enum": [+                      "xy",+                      "xz",+                      "yz"+                    ]+                  },+                  {+                    "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                    "required": [+                      "documentId",+                      "revision",+                      "objectType"+                    ],+                    "type": "object"+                  }+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          },+          "sketch_curve_edit": {+            "description": "Edit one native sketch curve with sketch-space mm pick. trim removes the nearest segment; extend chooses nearest endpoint; split requires an interior on-curve point; break uses neighboring intersections. Fresh replacement refs are returned; original may be deleted. In-place extend returns the original with a fresh ref only after its geometry change survives recompute. No change or empty break/split fails. Full trim deletion requires allowDelete true. Linked/derived/deferred-compute geometry refused.",+            "properties": {+              "action": {+                "enum": [+                  "trim",+                  "extend",+                  "split",+                  "break"+                ]+              },+              "allowDelete": {+                "type": "boolean"+              },+              "createConstraints": {+                "type": "boolean"+              },+              "curve": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "pick": {+                "items": {+                  "type": "number"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "sketch",+              "curve",+              "action",+              "pick"+            ],+            "type": "object"+          },+          "sketch_diagnostics": {+            "description": "Read native sketch health/message, fully-constrained/fixed/linked/reference flags, geometric constraints and driving dimensions. Reports no solver DOF count or conflict-set explanation; no recompute/mutation.",+            "properties": {+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "target",+              "sketch"+            ],+            "type": "object"+          },+          "sketch_dimension": {+            "description": "Add driving dimensions. Distance uses two point references; radius/diameter one curve; angle two lines. Numeric expressions use mm or deg.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "expression": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "parameterName": {+                "type": "string"+              },+              "position": {+                "items": {+                  "type": "number"+                },+                "maxItems": 3,+                "minItems": 2,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "type": {+                "enum": [+                  "distance",+                  "horizontal",+                  "vertical",+                  "radius",+                  "diameter",+                  "angle"+                ]+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "type",+              "entities",+              "expression",+              "position"+            ],+            "type": "object"+          },+          "sketch_edit": {+            "description": "Move sketch points/endpoints/centers in sketch-space mm, change radius or construction/fixed flags; solver failure aborts the operation.",+            "properties": {+              "changes": {+                "additionalProperties": false,+                "minProperties": 1,+                "properties": {+                  "center": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "construction": {+                    "type": "boolean"+                  },+                  "end": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "fixed": {+                    "type": "boolean"+                  },+                  "position": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  },+                  "radius": {+                    "type": "number"+                  },+                  "start": {+                    "items": {+                      "type": "number"+                    },+                    "maxItems": 3,+                    "minItems": 2,+                    "type": "array"+                  }+                },+                "required": [],+                "type": "object"+              },+              "entity": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "entity",+              "changes"+            ],+            "type": "object"+          },+          "sketch_geometry": {+            "description": "Create a transactionally grouped set of sketch primitives. Numeric geometry uses mm and arc sweeps/polygon angles use deg.",+            "properties": {+              "items": {+                "items": {+                  "oneOf": [+                    {+                      "additionalProperties": false,+                      "properties": {+                        "position": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "point"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "position"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "line"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "rectangle"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "radius": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        },+                        "type": {+                          "enum": [+                            "circle"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "radius"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "sweep": {+                          "type": "number"+                        },+                        "type": {+                          "enum": [+                            "arc"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "start",+                        "sweep"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "angle": {+                          "type": "number"+                        },+                        "center": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "radius": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        },+                        "sides": {+                          "maximum": 128,+                          "minimum": 3,+                          "type": "integer"+                        },+                        "type": {+                          "enum": [+                            "polygon"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "center",+                        "radius",+                        "sides"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "construction": {+                          "type": "boolean"+                        },+                        "end": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "start": {+                          "items": {+                            "type": "number"+                          },+                          "maxItems": 3,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "slot"+                          ]+                        },+                        "width": {+                          "exclusiveMinimum": 0,+                          "type": "number"+                        }+                      },+                      "required": [+                        "type",+                        "start",+                        "end",+                        "width"+                      ],+                      "type": "object"+                    },+                    {+                      "additionalProperties": false,+                      "properties": {+                        "closed": {+                          "type": "boolean"+                        },+                        "construction": {+                          "type": "boolean"+                        },+                        "points": {+                          "items": {+                            "items": {+                              "type": "number"+                            },+                            "maxItems": 3,+                            "minItems": 2,+                            "type": "array"+                          },+                          "maxItems": 128,+                          "minItems": 2,+                          "type": "array"+                        },+                        "type": {+                          "enum": [+                            "spline"+                          ]+                        }+                      },+                      "required": [+                        "type",+                        "points"+                      ],+                      "type": "object"+                    }+                  ]+                },+                "maxItems": 128,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "items"+            ],+            "type": "object"+          },+          "sketch_offset": {+            "description": "Modern createOffsetInput/addOffset2. Curves must be native 2D, unique, in connected flow order (never reordered). Nonzero signed mm number/expression: positive right, negative left; a single circle/ellipse positive outside. Topology matched defaults true. Read back native signed distance, parent/child refs and controlling parameter after recompute. No retired Sketch.offset fallback.",+            "properties": {+              "curves": {+                "items": {+                  "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "distance": {+                "oneOf": [+                  {+                    "type": "number"+                  },+                  {+                    "type": "string"+                  }+                ]+              },+              "sketch": {+                "description": "Current guarded entity reference; root-space child geometry requires its exact occurrence context.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              },+              "topologyMatched": {+                "type": "boolean"+              }+            },+            "required": [+              "op",+              "target",+              "sessionId",+              "operationId",+              "sketch",+              "curves",+              "distance"+            ],+            "type": "object"+          },+          "sketch_project": {+            "description": "Project selected topology into a sketch with Fusion associative projection.",+            "properties": {+              "entities": {+                "items": {+                  "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                  "required": [+                    "documentId",+                    "revision",+                    "objectType"+                  ],+                  "type": "object"+                },+                "maxItems": 256,+                "minItems": 1,+                "type": "array"+              },+              "sketch": {+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring.",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "type": "object"+              }+            },+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target",+              "sketch",+              "entities"+            ],+            "type": "object"+          },+          "transaction_probe": {+            "description": "Verify runtime PTransaction abort+commit using temporary user parameters, remove probe data and compare semantic restoration. Required once per running add-in session before feature/sketch/atomic-batch writes. Returns fresh target; inspect again for current references.",+            "properties": {},+            "required": [+              "op",+              "sessionId",+              "operationId",+              "target"+            ],+            "type": "object"+          }+        },+        "sessionId": "required for writes from mech_capabilities",+        "target": "existing-document writes: {documentId,revision} from inspect"+      },+      "longRunning": true,+      "name": "fusion_mechanical",+      "output": {+        "data": "operation result including fresh target",+        "durability": "terminalRecorded and recorded phase for durable writes",+        "errorCode": "stable str on failure",+        "operationId": "str on writes",+        "outcome": "unknown or not_executed on storage/delivery failure",+        "recovery": "reported on failed mutation",+        "sessionId": "str",+        "success": "bool"+      },+      "statusVerb": "fusion_mech_operation_status",+      "summary": "Guarded main-thread parametric parts and assemblies: sketches, solid features, atomic parameter edits, component definitions/copies/placement, seven as-built joint motions and limits, rigid groups, interference, materials and assembly mass/center of mass, local supplier STEP/SAT import with SHA/provenance, native McMaster command, structured/flat BOM CSV, topology readback, health and safe exports. Geometry queries refuse ambiguous selections; root-space distance/angle measurements return witness points. Typed sketch trim/extend/split/break and signed modern offsets, reference-defined construction axes and native sketch constraint diagnostics are available through exact operation schemas. Regular geometry-solving joints, joint origins and native motion links have guarded typed operations, exact attachment/parameter readback and timeline restoration. Read-only configuration inspection and active-row BOM provenance are available; configuration lifecycle and configured-design model writes remain disabled pending native recovery/archive gates. Incomplete configuration scope also blocks complete BOM output. Typed model mutations use runtime-proven PTransaction recovery; transaction_probe verifies the backend (new_design does this automatically). Writes require sessionId,operationId and current target {documentId,revision}. Durable admission must commit before dispatch. Retry exact args with the same ID; query durable status after timeout. Old-session history is readable but never replayed. Storage failure after execution returns reconciliation-required, preserving available evidence without claiming rollback. References expire on model changes. Files/document lifecycle are outside model transactions.",+      "timeoutSeconds": 300+    },     {       "example": {},       "input": {@@ -2177,76 +19340,178 @@     },     {       "example": {-        "brdPath": "C:/Users/me/adom-lib/MyBoard.brd",-        "schPath": "C:/Users/me/adom-lib/MyBoard.sch"+        "expectDocument": "fusion-routing"       },       "input": {-        "brdPath": "optional str (defaults to sibling .brd)",-        "schPath": "required str (Windows path to .sch)"+        "boardId": "optional",+        "expectDocument": "required exact active board name"       },       "longRunning": false,-      "name": "fusion_new_electronics_from_eagle",+      "name": "fusion_net_classes",       "output": {-        "imported": "list",-        "success": "bool"+        "classes": "[{name,number,widthMm,drillMm,clearances:[{toClass,mm}],nets}]",+        "count": "int"       },-      "statusVerb": null,-      "summary": "Import a legacy EAGLE .sch (+ paired .brd) into a NEW Fusion electronics design so the parts INSTANTIATE (schematic + populated board, lands in the PCB editor). The ONLY way to author a board from EAGLE source: Document.newDesignFromLocal opens the schematic editor but does NOT instantiate parts, and the Fusion-native .fsch/.fbrd container is opaque binary you can't build offline. This fires Fusion's own ImportSCHAndBRDCmd and drives BOTH native Open dialogs (the .sch then the .brd) in the BACKGROUND via desktop_ui_click by accessible name (no foreground). Stage both files to Windows first (send_files). After: fusion_show_2d_board, RATSNEST + 'AUTO ;' to autoroute, fusion_show_3d_board for 3D. PREFLIGHT (1.10.20): refuses with eagle_files_missing before touching any dialog when either file is not on the Fusion machine; if the Open dialog does not accept the file the bridge cancels the dialog itself (open_dialog_stuck), so nothing is ever left on the user's screen. Prefer fusion_schematic {action:\"open\"}, which picks this route only when a .brd exists next to the .sch. ASYNC by contract (1.10.22): returns {started:true, runId, statusVerb} at once and runs the dialog-driven import on the exe; poll fusion_eagle_import_status {runId}. The record and the final reply carry documentName, partsExpected (elements in the .brd) and partsPlaced (read back from the board); success needs parts on the board (nothing_instantiated otherwise). Pass wait:true only from inside the exe.",-      "timeoutSeconds": 200+      "statusVerb": "fusion_routing_state",+      "summary": "The board's net classes with their width, drill, class-to-class clearances and member nets.",+      "timeoutSeconds": 60     },     {       "example": {-        "body": "Please complete the Autodesk 2FA prompt on winvm - everything else is done.",-        "title": "Fusion needs you"+        "expectDocument": "fusion-routing"       },       "input": {-        "body": "required str",-        "level": "optional str info|warning|error",-        "title": "optional str"+        "boardId": "optional",+        "expectDocument": "required exact active board name",+        "limit": "int, default 4000 pads",+        "net": "optional: one net (case-insensitive)"       },       "longRunning": false,-      "name": "fusion_notify_owner",+      "name": "fusion_net_connections",       "output": {-        "success": "bool",-        "targets": "list"+        "count": "int",+        "nets": "[{net,pads,span:[x0,y0,x1,y1],airlineMm}]",+        "pads": "[{net,pad,x,y,layer}]"       },-      "statusVerb": null,-      "summary": "LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-ab to every peer on the relay, so it reaches them even when this bridge runs on an unattended VM). ONLY for true human walls - password/2FA entry, UAC elevation, a physical step. Exhaust programmatic options first (UIA background clicks, seat auto-resolve, warm-SSO sign-in). After sending, WAIT and poll fusion_readiness; do not re-toast within a few minutes.",-      "timeoutSeconds": 20+      "statusVerb": "fusion_routing_state",+      "summary": "Every pad with its net as Designator.Pad and position, and per net its span and airline length (the minimum spanning tree over its pads, the shortest copper that could join them). net filters to one net.",+      "timeoutSeconds": 60     },     {       "example": {-        "filePath": "C:/Temp/TJA1050.brd"+        "nets": [+          "D_P",+          "D_N"+        ]       },       "input": {-        "filePath": "required str (WINDOWS path to the .brd, C:/...; must exist on the Fusion machine)"+        "expectDocument": "required: the board's name",+        "groups": "[{nets, toleranceMm?}]",+        "nets": "[net] (default every routed net)",+        "pairs": "[{name?, pos, neg}]"       },-      "longRunning": true,-      "name": "fusion_open_board",+      "longRunning": false,+      "name": "fusion_net_lengths",       "output": {-        "activeDocument": "str",-        "activeWorkspace": "str",-        "filePath": "str",-        "fileType": "str",-        "nextSteps": "[str]",-        "postOpenCheck": "{required, steps}",-        "screenshots": "[{type,savedTo,sizeKB}] (sidecar shell) or postOpenScreenshot (exe shell)",-        "success": "bool"+        "engine": "str",+        "groups": "[{nets, spreadMm, withinTolerance, longest}]",+        "nets": "[{net, lengthMm, byLayer, vias, segments}]",+        "pairs": "[{name, pos, neg, posMm, negMm, skewMm}]"       },       "statusVerb": null,-      "summary": "Open a LOCAL legacy EAGLE .brd in Fusion's 2D board editor (dialog-free Document.newDesignFromLocal; a background open). NAV RULE: the schematic, 2D board and 3D board are VIEWS of ONE electronics design, not standalone files. For a team design open the DESIGN document (fusion_open_cloud_file / fusion_open_by_urn) and switch views with fusion_show_2d_board; this verb is for a .brd that exists on the Fusion machine (push it there first). Elements with an embedded library are instantiated as placed parts; embed <packages3d> + per-element package3d_urn for real 3D bodies, then fusion_show_3d_board. The bridge captures a post-open screenshot because Fusion can raise a blocking dialog the API cannot see.",-      "timeoutSeconds": 60+      "summary": "Routed length of every net (or the ones named) on the live board, by layer with its vias; the skew inside each differential pair (default the pairs the net names spell, as fusion_diff_pairs); and the spread of matched-length groups against a tolerance (the standard's net_lengths): the shared checks engine.",+      "timeoutSeconds": 120     },     {       "example": {-        "urn": "urn:adsk.wipprod:fs.file:vf.xxxx?version=1"+        "expectDocument": "fusion-routing"       },       "input": {-        "intent": "optional \"mechanical\" | \"electronics\": what you meant to open. A DesignProductType is every mechanical design; the STOP-WRONG-FILE hint now fires only for the 3D leaf of an electronics chain (by name, or intent electronics); intent mechanical confirms the open (issue #86)",-        "urn": "required str"+        "expect": "optional {net:[\"U1.3\",...]}: compare pin by pin",+        "expectDocument": "the active board's exact name (live read)",+        "net": "optional: one net (case-insensitive)",+        "schPath": "OR an EAGLE .sch / Fusion .fsch on the Fusion machine (file read, Fusion need not run)"       },-      "longRunning": true,-      "name": "fusion_open_by_urn",+      "longRunning": false,+      "name": "fusion_netlist",+      "output": {+        "mismatches": "[{net,missing,extra} | {net,unexpected}] (with expect)",+        "netCount": "int",+        "nets": "{net:[ref.pad]}",+        "ok": "bool (with expect)",+        "pinsWithoutPad": "[part.gate.pin] (schPath: supply symbols and pins with no pad)",+        "revision": "str (live)"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The compiled netlist: every net with its pads as Designator.Pad (U1.3). From the live board in the background (expectDocument; Fusion keeps board and schematic in sync), or from a schematic FILE without Fusion (schPath: an EAGLE .sch or Fusion .fsch; pins resolved to pads through each device's connects). expect compares it pin by pin with the circuit you meant; net returns one net.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "brdPath": "C:/Users/me/adom-lib/MyBoard.brd",+        "schPath": "C:/Users/me/adom-lib/MyBoard.sch"+      },+      "input": {+        "brdPath": "optional str (defaults to sibling .brd)",+        "schPath": "required str (Windows path to .sch)"+      },+      "longRunning": false,+      "name": "fusion_new_electronics_from_eagle",+      "output": {+        "imported": "list",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Import a legacy EAGLE .sch (+ paired .brd) into a NEW Fusion electronics design so the parts INSTANTIATE (schematic + populated board, lands in the PCB editor). The ONLY way to author a board from EAGLE source: Document.newDesignFromLocal opens the schematic editor but does NOT instantiate parts, and the Fusion-native .fsch/.fbrd container is opaque binary you can't build offline. This fires Fusion's own ImportSCHAndBRDCmd and drives BOTH native Open dialogs (the .sch then the .brd) in the BACKGROUND via desktop_ui_click by accessible name (no foreground). Stage both files to Windows first (send_files). After: fusion_show_2d_board, RATSNEST + 'AUTO ;' to autoroute, fusion_show_3d_board for 3D. PREFLIGHT (1.10.20): refuses with eagle_files_missing before touching any dialog when either file is not on the Fusion machine; if the Open dialog does not accept the file the bridge cancels the dialog itself (open_dialog_stuck), so nothing is ever left on the user's screen. Prefer fusion_schematic {action:\"open\"}, which picks this route only when a .brd exists next to the .sch. ASYNC by contract (1.10.22): returns {started:true, runId, statusVerb} at once and runs the dialog-driven import on the exe; poll fusion_eagle_import_status {runId}. The record and the final reply carry documentName, partsExpected (elements in the .brd) and partsPlaced (read back from the board); success needs parts on the board (nothing_instantiated otherwise). Pass wait:true only from inside the exe.",+      "timeoutSeconds": 200+    },+    {+      "example": {},+      "input": {+        "verb": "one of them (optional): its refusal"+      },+      "longRunning": false,+      "name": "fusion_not_supported",+      "output": {+        "verbs": "[{verb, why}]"+      },+      "statusVerb": null,+      "summary": "The standard verbs that belong to Altium's own machinery (the Altium 365 cloud and workspace, the DelphiScript agent, the .NET extension, integrated libraries, OutJobs, symbol display modes, library defaults) and what Fusion does instead. Calling any of them, fusion_<verb> or the bare name, answers not_supported through this verb; with no verb it lists them.",+      "timeoutSeconds": 10+    },+    {+      "example": {+        "body": "Please complete the Autodesk 2FA prompt on winvm - everything else is done.",+        "title": "Fusion needs you"+      },+      "input": {+        "body": "required str",+        "level": "optional str info|warning|error",+        "title": "optional str"+      },+      "longRunning": false,+      "name": "fusion_notify_owner",+      "output": {+        "success": "bool",+        "targets": "list"+      },+      "statusVerb": null,+      "summary": "LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-ab to every peer on the relay, so it reaches them even when this bridge runs on an unattended VM). ONLY for true human walls - password/2FA entry, UAC elevation, a physical step. Exhaust programmatic options first (UIA background clicks, seat auto-resolve, warm-SSO sign-in). After sending, WAIT and poll fusion_readiness; do not re-toast within a few minutes.",+      "timeoutSeconds": 20+    },+    {+      "example": {+        "filePath": "C:/Temp/TJA1050.brd"+      },+      "input": {+        "filePath": "required str (WINDOWS path to the .brd, C:/...; must exist on the Fusion machine)"+      },+      "longRunning": true,+      "name": "fusion_open_board",+      "output": {+        "activeDocument": "str",+        "activeWorkspace": "str",+        "filePath": "str",+        "fileType": "str",+        "nextSteps": "[str]",+        "postOpenCheck": "{required, steps}",+        "screenshots": "[{type,savedTo,sizeKB}] (sidecar shell) or postOpenScreenshot (exe shell)",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Open a LOCAL legacy EAGLE .brd in Fusion's 2D board editor (dialog-free Document.newDesignFromLocal; a background open). NAV RULE: the schematic, 2D board and 3D board are VIEWS of ONE electronics design, not standalone files. For a team design open the DESIGN document (fusion_open_cloud_file / fusion_open_by_urn) and switch views with fusion_show_2d_board; this verb is for a .brd that exists on the Fusion machine (push it there first). Elements with an embedded library are instantiated as placed parts; embed <packages3d> + per-element package3d_urn for real 3D bodies, then fusion_show_3d_board. The bridge captures a post-open screenshot because Fusion can raise a blocking dialog the API cannot see.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "urn": "urn:adsk.wipprod:fs.file:vf.xxxx?version=1"+      },+      "input": {+        "intent": "optional \"mechanical\" | \"electronics\": what you meant to open. A DesignProductType is every mechanical design; the STOP-WRONG-FILE hint now fires only for the 3D leaf of an electronics chain (by name, or intent electronics); intent mechanical confirms the open (issue #86)",+        "urn": "required str"+      },+      "longRunning": true,+      "name": "fusion_open_by_urn",       "output": {         "output": "str",         "success": "bool"@@ -2302,6 +19567,21 @@       "summary": "Open a LOCAL design file (routes through the add-in import). Prefer cloud flows (fusion_open_cloud_file) for team designs; this is for local .f3d/.step style files.",       "timeoutSeconds": 240     },+    {+      "example": {},+      "input": {+        "...": "as fusion_open_design"+      },+      "longRunning": false,+      "name": "fusion_open_document",+      "output": {+        "...": "as fusion_open_design",+        "aliasOf": "fusion_open_design"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_open_design: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {@@ -2365,6 +19645,60 @@       "summary": "Open a LOCAL legacy EAGLE .sch in Fusion's Schematic Editor (dialog-free Document.newDesignFromLocal; a background open). NAV RULE: the schematic, 2D board and 3D board are VIEWS of ONE electronics design, not standalone files. For a team design open the DESIGN document (fusion_open_cloud_file / fusion_open_by_urn) and switch views with fusion_show_schematic; this verb is for a .sch that exists on the Fusion machine (push it there first). Drive the opened sheet with fusion_electron_run (WINDOW FIT, DISPLAY ALL). The bridge captures a post-open screenshot because Fusion can raise a blocking dialog the API cannot see.",       "timeoutSeconds": 60     },+    {+      "example": {+        "cols": 3,+        "dryRun": true,+        "rows": 2,+        "separation": "vscore"+      },+      "input": {+        "cols": "int (required)",+        "dryRun": "bool",+        "expectDocument": "required",+        "gapMm": "tabs: the routed gap",+        "open": "bool, default true",+        "outputPath": "the panel .brd (default %TEMP%/adom-panels)",+        "railMm": "default 5",+        "rows": "int (required)",+        "separation": "none | vscore | tabs",+        "toolingHoles": "bool, default true"+      },+      "longRunning": false,+      "name": "fusion_panelize",+      "output": {+        "boardsAt": "[[x, y]]",+        "built": "{copies, parts, holes, fiducials}",+        "copyShift": "[[dx, dy]]",+        "documentName": "str",+        "jlcpcb": "{rules, fits}",+        "panelMm": "[w, h]",+        "pcbPath": "path",+        "readBack": "{components, expected, unconnected, outlineClosed}",+        "separation": "{kind, cutsX?, cutsY?, tabs?}"+      },+      "statusVerb": null,+      "summary": "A manufacturing panel (the standard's panelize), planned by the shared checks engine: rows x cols copies, V-score lines or mouse-bite tabs drawn the way JLCPCB reads them, rails with tooling holes and fiducials, JLCPCB's panel rules checked. Fusion builds it as a NEW EAGLE board from the open board's source (copy k's parts and nets renamed _k, the copies' own outline left to the panel's rout path) and opens it as a local design; the board you panelized is untouched. dryRun returns the plan.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "name": "MPN"+      },+      "input": {+        "expectDocument": "the design",+        "name": "an attribute, e.g. MPN"+      },+      "longRunning": false,+      "name": "fusion_part_parameters",+      "output": {+        "names": "[{name, parts}]",+        "values": "[{designator, value, sheet}] (with name)"+      },+      "statusVerb": null,+      "summary": "The attribute names the design's placed parts carry, with how many carry each (the standard's part_parameters); with name, that attribute's value on every part.",+      "timeoutSeconds": 120+    },     {       "example": {         "accuracy": "low"@@ -2384,6 +19718,49 @@       "summary": "Per-component physical properties (volume cm3, mass kg, density, area, center of mass) for the active design. Reads them directly so BOM/costing tools no longer have to run getPhysicalProperties inside a modeling script. Pass names to scope to specific components.",       "timeoutSeconds": 120     },+    {+      "example": {},+      "input": {+        "expectDocument": "the design"+      },+      "longRunning": false,+      "name": "fusion_pin_pad_check",+      "output": {+        "engine": "str",+        "ok": "bool",+        "onlyOnBoard": "[ref]",+        "onlyOnSheets": "[ref]",+        "parts": "[{designator, pinsWithoutPad, padsWithoutPin}]"+      },+      "statusVerb": null,+      "summary": "Do the footprints fit their symbols (the standard's pin_pad_check)? Part by part, the symbol's pin numbers (fusion_schematic_data) against the placed footprint's pad names on the board: pins with no pad, pads with no pin, and parts only on the sheets or only on the board. The shared checks engine.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "ic": "U1"+      },+      "input": {+        "caps": "[ref] (default the caps on its power nets)",+        "expectDocument": "required: the board's name",+        "gapMm": "cap to IC box, default the engine's",+        "ic": "the IC (required)"+      },+      "longRunning": false,+      "name": "fusion_place_decoupling",+      "output": {+        "engine": "str",+        "leftOut": "[{cap, net, why, detail}]",+        "moveArgs": "fusion_move_parts' arguments",+        "placements": "[{cap, net, pin, powerPad, x, y, rotation, side, padToPinMm, from}]",+        "revision": "str",+        "skipped": "[{cap, pin, why}]",+        "validation": "placement_check with the caps moved"+      },+      "statusVerb": null,+      "summary": "Plan decoupling capacitors beside an IC's power pins (the standard's place_decoupling), from the shared checks engine: each cap gapMm outside the IC's box on the side of the power pin it serves, turned so its power pad faces the pin, slid along that side when the spot is taken; the plan is checked with placement_check. A plan: moveArgs is fusion_move_parts' arguments, boardId and expectedRevision included.",+      "timeoutSeconds": 150+    },     {       "example": {},       "input": {@@ -2404,6 +19781,64 @@       "summary": "Add vias at exact points (stitching, thermal, escape): VIA per via with its drill and diameter, then read back.",       "timeoutSeconds": 120     },+    {+      "example": {+        "marginMm": 0.25+      },+      "input": {+        "edgeMm": "pad to edge, default 0.5",+        "expectDocument": "required: the board's name",+        "marginMm": "courtyard margin, default 0.1"+      },+      "longRunning": false,+      "name": "fusion_placement_check",+      "output": {+        "bodiesUsed": "bool",+        "courtyardOverlaps": "[{parts, side, overlapMm}]",+        "engine": "str",+        "nearEdge": "[{ref, padToEdgeMm}]",+        "offOrOverEdge": "[{ref, where}]",+        "ok": "bool",+        "onMountingHoles": "[{ref, hole}]",+        "parts": "int"+      },+      "statusVerb": null,+      "summary": "Review the placement before routing (the standard's placement_check): parts whose courtyards (pads and 3D body, grown by marginMm) overlap on the same side, parts off or over the board edge, pads closer than edgeMm to the edge, and parts on a mounting hole: the shared checks engine on the live board and fusion_bodies (pads only, bodiesUsed:false, when the bodies cannot be read).",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "ref": "U1"+      },+      "input": {+        "clearanceMm": "can only raise the board's",+        "escapeLayer": "copper layer",+        "expectDocument": "required: the board's name",+        "ref": "the part (required)",+        "stubMm": "stub length",+        "style": "BGA: dogbone|via-in-pad",+        "viaDrillMm": "mm",+        "viaMm": "via size",+        "viaPerimeter": "bool: a via at every perimeter stub",+        "widthMm": "stub width"+      },+      "longRunning": false,+      "name": "fusion_plan_fanout",+      "output": {+        "callCount": "int",+        "calls": "[fusion_route_net arguments]",+        "conflicts": "[{from, what, pad, padNet, gapMm}]",+        "engine": "str",+        "package": "str",+        "pads": "[{pad, net, action, ...}]",+        "revision": "str",+        "viaCount": "int",+        "warnings": "[str]"+      },+      "statusVerb": null,+      "summary": "Plan a part's fanout (the standard's plan_fanout), from the shared checks engine on the live board and its stack-up: a BGA's outer ring escapes on the surface and each inner ball takes a dogbone via (or a via in the pad); a perimeter package's pads take an outward stub (a via at its end for ground, or with viaPerimeter); an exposed pad a via grid. calls are fusion_route_net arguments, one per net; conflicts lists vias and stubs that would come too close to another net's pad.",+      "timeoutSeconds": 150+    },     {       "example": {         "parts": [@@ -2434,33 +19869,50 @@       "timeoutSeconds": 20     },     {-      "example": {},+      "example": {+        "from": "U1.12",+        "layers": [+          "F.Cu",+          "In1.Cu",+          "In2.Cu",+          "B.Cu"+        ],+        "net": "SDA",+        "to": "J3.4"+      },       "input": {         "allowVias": "bool default true",-        "boardId": "required str",-        "expectDocument": "required str",-        "expectedRevision": "required str",-        "fromPad": "required str",-        "grid": "mm 0.1..5 default 0.5",-        "maxNodes": "int 1..100000 default 25000",+        "clearanceMm": "can only raise the board's",+        "edgeClearanceMm": "can only raise the board's",+        "expectDocument": "required: the board's name",+        "from": "the start pad as Ref.Pad",+        "gridMm": "0.05..5, default 0.5",+        "layers": "[copper layer] default [F.Cu, B.Cu]; list them all (e.g. [F.Cu, In1.Cu, In2.Cu, B.Cu]) so a via is checked on every layer it passes",+        "maxNodes": "default 50000",         "net": "required str",-        "timeoutMs": "int 10..5000 default 3000",-        "toPad": "required str",-        "viaCost": "mm-equivalent cost default 5",-        "viaDiameter": "mm default 0.6",-        "viaDrill": "mm default 0.3",-        "width": "mm default 0.25"+        "to": "the end pad",+        "viaCost": "a via costs as much as this many mm, default 5",+        "viaDrillMm": "default the board's via rule",+        "viaSizeMm": "default the board's via rule",+        "widthMm": "default the board's width rule, else 0.25"       },       "longRunning": false,       "name": "fusion_plan_route",       "output": {+        "engine": "str",+        "found": "bool",+        "lengthMm": "number",         "mutated": "false",-        "plan": "{items,route,planner}",+        "planner": "{algorithm, gridMm, layers, clearanceMm, edgeClearanceMm, widthFrom, viaFrom}",+        "reason": "str (found false)",         "revision": "str",-        "success": "bool"+        "routeNet": "fusion_route_net's arguments",+        "success": "bool",+        "viaAt": "[[x,y]]",+        "vias": "int"       },       "statusVerb": "fusion_routing_state",-      "summary": "Calculate a read-only, bounded orthogonal A* path between two pads on a live two-layer board. Uses existing copper and the shared conservative clearance model. Returns explicit route args for route_net; native DRC is still required after mutation.",+      "summary": "Plan a path for one net between two pads on the live board without changing it (the standard's plan_route), from the shared checks engine (adom-eda-checks): a bounded orthogonal A* on any copper layers listed (default F.Cu and B.Cu), with through vias between them; pads by their real outline, the board's strictest copper clearance and copper-to-edge rule. Answered as routeNet, fusion_route_net's arguments (boardId and expectedRevision included), to pass on unchanged; found:false with a reason when no path fits. Pours are not obstacles: fusion_route_net undoes a route that cuts another net's pour in two. Fine-pitch pads need gridMm 0.1.",       "timeoutSeconds": 60     },     {@@ -2476,7 +19928,8 @@         "filledAreaByNetMm2": "{net:mm2}",         "pours": "list",         "revision": "str",-        "unfilled": "[net]"+        "unfilled": "[net]",+        "zones": "[{net,layer,outline,filledMm2,filled,fills:[{outline,holes}]}] (the standard's pours model)"       },       "statusVerb": "fusion_routing_state",       "summary": "Read every pour on the live board with Fusion's own computed fill: filled area per pour, per layer and per net, and which pours were never filled (no RATSNEST since they were drawn). The measure step of the AI flow's Fusion lane.",@@ -2552,258 +20005,1684 @@       "timeoutSeconds": 120     },     {-      "example": {-        "runId": "a3f1c2d4e5b6"-      },+      "example": {},       "input": {-        "inlineFrames": "optional bool",-        "runId": "optional str (omit for the latest run)",-        "shots": "optional int",-        "sinceShot": "optional int"-      },-      "longRunning": true,-      "name": "fusion_prove_result",-      "output": {-        "etaSec": "float",-        "evidence": "[]",-        "percent": "float",-        "stage": "str",-        "verdict": "str"+        "recent": "how many recent runs, default 10"       },-      "statusVerb": null,-      "summary": "POLL a background run started by fusion_create_library or the detached fusion_build_library_3d. Returns stage + stageLabel, plan[] with measured per-stage estimates, stagesDone, percent, etaSec, confidence, and evidence[] filling in AS EACH ARTIFACT LANDS (symbol -> footprint -> 3d -> ganged). For a 3D build it carries per-part progress (minting X (3/7)), partsDone/partsTotal and parts[] with each wip_urn. stage:done only means the chain FINISHED - the top-level verdict (proven/not_proven) is the score, and a run that captured zero frames lands stage:failed with blocked_by_dialog (carrying the dialog text) or no_evidence_captured rather than reporting done. Pass inlineFrames:true on the final fetch for base64 thumbnails a browser can render. restarts[] {at, why, kind} lists any restart the chain performed (only with allowRestart). prove.planned / prove.skipped say whether evidence frames were captured and why (AI threads bind only by default).",-      "timeoutSeconds": 20-    },-    {-      "example": {},-      "input": {},       "longRunning": false,-      "name": "fusion_readiness",+      "name": "fusion_progress",       "output": {-        "bridgeVersion": "str",-        "hostApp": "str",-        "installed": "bool",-        "ready": "bool",-        "running": "bool"+        "active": "[{verb, runningSec, estimateSec}]",+        "history": "{phase: {runs, p50, max}}",+        "recentRuns": "[{at, verb, seconds, ok}]",+        "verbTimes": "{verb: {runs, p50, max}}"       },       "statusVerb": null,-      "summary": "FAST readiness check (does NOT launch Fusion): is the Fusion host app installed + running + the bridge ready to drive? ab DETECTS Fusion (never installs it) via bridge.json 'detect', and auto-installs Python if missing (ab >=1.9.47). Call this before driving Fusion; if installed-but-not-running, fusion_start. SELF-HEALS the seat/licensing dialog (background UIA + screenshot-verify) whenever it detects one. Pairs with ab's bridge_readiness.",-      "timeoutSeconds": 15+      "summary": "The bridge's timing book (the standard's progress): the long operation in flight now with how long it has run and its usual time, the measured phase timings, per-verb run times (p50, max) and the most recent runs.",+      "timeoutSeconds": 10     },     {-      "example": {},+      "example": {+        "dryRun": true,+        "layers": 4,+        "name": "Sensor-Hub",+        "parentDir": "C:/Users/me/Documents/Boards",+        "textVariables": {+          "REV": "A"+        },+        "title": "Sensor hub"+      },       "input": {-        "save": "optional bool (default false): save open documents before closing"+        "dryRun": "bool",+        "fabRules": "a fab from adom/pcb-design-rules, recorded for later",+        "layers": "2|4|6|8, default 2",+        "name": "the design's name (required)",+        "overwrite": "bool",+        "parentDir": "a folder on the Fusion machine (required)",+        "textVariables": "{'REV': 'A'}",+        "title": "str"       },       "longRunning": false,-      "name": "fusion_release_seat",+      "name": "fusion_project_create",       "output": {-        "released": "bool",-        "success": "bool",-        "wasHeldBy": "obj"+        "files": "[sch, brd]",+        "layerSetup": "str",+        "layers": "int",+        "project": "folder",+        "steps": "[str]"       },       "statusVerb": null,-      "summary": "Give up the Autodesk seat from THIS machine so another box can claim it with no modal at all: closes Fusion cleanly (documents are NOT discarded; an unsaved one refuses and says so) and leaves the account signed in, so this box can claim the seat straight back. The counterpart of fusion_claim_seat.",+      "summary": "A new, empty electronics design (the standard's project_create): an empty schematic and board written as EAGLE source in <parentDir>/<name>/ (the board's copper count in its layer setup; title and text variables as the schematic's global attributes) and opened in Fusion as a new design, dialog-free. Save it to the cloud with fusion_save_to_cloud.",       "timeoutSeconds": 180     },     {-      "example": {},+      "example": {+        "expectDocument": "BQ25792"+      },       "input": {-        "boardId": "required",-        "expectDocument": "required exact board name",-        "expectedRevision": "required",-        "pours": "optional 'all' (default) or [{net, layer, points}]"+        "expectDocument": "the design's name (default the document in front)",+        "project": "the same, in the standard's word"       },       "longRunning": false,-      "name": "fusion_remove_pours",+      "name": "fusion_project_info",       "output": {-        "left": "list",-        "removed": "int",-        "revision": "str",-        "success": "bool"+        "board": "{layers, parts, nets, sizeMm}",+        "files": "[{kind, name, open, saved, modified, path, version, modifiedAt}]",+        "modifiedAt": "epoch s",+        "name": "str",+        "netClasses": "[str]",+        "project": "the cloud project",+        "sheets": "the tree, as sch_hierarchy"       },-      "statusVerb": "fusion_routing_state",-      "summary": "Delete pours (all of them, or the ones named by net, layer and outline) so a board can be poured again after a refine. Each DELETE picks the outline point farthest from every pad (refused if none is 1 mm clear), and the readback undoes everything if a part or a track changed.",+      "statusVerb": null,+      "summary": "A Fusion electronics design at a glance (the standard's project_info): its documents (the open ones and its cloud files of the same name: project, schematic, board, 3D PCB) with version and date, the sheet tree, the board (copper layers, parts, nets, size) and its net classes. Read only; the design must be open.",       "timeoutSeconds": 120     },     {-      "example": {},+      "example": {+        "dryRun": true,+        "newName": "Sensor-Hub-v2",+        "project": "C:/Boards/Sensor-Hub"+      },       "input": {-        "force": "optional bool default false - also discard MODIFIED Untitled docs"+        "dryRun": "bool",+        "newName": "str (required)",+        "project": "a .sch, .brd or the folder holding them, on the Fusion machine (required)"       },       "longRunning": false,-      "name": "fusion_reset_workspace",+      "name": "fusion_project_rename",       "output": {-        "closedByAddin": "list",-        "remaining": "list",-        "success": "bool",-        "untitledScratchClosed": "int"+        "changed": "[]",+        "renamed": "[{from, to}]"       },       "statusVerb": null,-      "summary": "Bring Fusion back to a clean slate between runs: closes named documents AND the Untitled scratch the library/bind flow leaves behind (page issue #59). Fusion always keeps ONE blank document alive, so a single remaining Untitled is correct rather than a failure. MODIFIED Untitled docs are left untouched unless force:true, because those can hold real unsaved work.",-      "timeoutSeconds": 90+      "summary": "Rename a design kept as EAGLE files (the standard's project_rename): <name>.sch, .brd, .lbr and EAGLE's numbered backups become <newName>.*, and a folder named after the design is renamed with them. EAGLE files do not name each other, so nothing inside changes. Refused while Fusion has the design open. A Fusion cloud design is renamed in Fusion's data panel.",+      "timeoutSeconds": 30     },     {-      "example": {},+      "example": {+        "expectDocument": "BQ25792",+        "label": "before-reroute"+      },       "input": {-        "maxClicks": "optional int (default 3)"+        "expectDocument": "the design's name (default the document in front)",+        "label": "added to the folder name",+        "outputDir": "default Documents/Adom Snapshots/<design>",+        "pdfs": "bool, default true"       },       "longRunning": false,-      "name": "fusion_resolve_seat_dialog",+      "name": "fusion_project_snapshot",       "output": {-        "clicks": "int",-        "resolved": "bool"+        "files": "[path]",+        "folder": "path",+        "notes": "[str]",+        "pdfs": "{made: [path], skipped}"       },       "statusVerb": null,-      "summary": "Readiness EXECUTOR (Rust port, Phase 3): detect + resolve the Autodesk seat/licensing modal ('Active Sessions Exceeded' / 'Suspend Remote Session') in the background, at most 3 UIA clicks per call, screenshot-verified. Idempotent: nothing up answers clicks:0. fusion_readiness calls this itself when it sees the dialog; call it directly only when you are driving the launch by hand.",+      "summary": "A dated plain-file copy of a Fusion design (the standard's project_snapshot): a folder on the Fusion machine with the schematic and board as EAGLE XML, a PNG of every sheet and of the board, and PDFs made from them. Fusion's cloud versions stay as they are; save one with fusion_save_document.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "runId": "a3f1c2d4e5b6"+      },+      "input": {+        "inlineFrames": "optional bool",+        "runId": "optional str (omit for the latest run)",+        "shots": "optional int",+        "sinceShot": "optional int"+      },+      "longRunning": true,+      "name": "fusion_prove_result",+      "output": {+        "etaSec": "float",+        "evidence": "[]",+        "percent": "float",+        "stage": "str",+        "verdict": "str"+      },+      "statusVerb": null,+      "summary": "POLL a background run started by fusion_create_library or the detached fusion_build_library_3d. Returns stage + stageLabel, plan[] with measured per-stage estimates, stagesDone, percent, etaSec, confidence, and evidence[] filling in AS EACH ARTIFACT LANDS (symbol -> footprint -> 3d -> ganged). For a 3D build it carries per-part progress (minting X (3/7)), partsDone/partsTotal and parts[] with each wip_urn. stage:done only means the chain FINISHED - the top-level verdict (proven/not_proven) is the score, and a run that captured zero frames lands stage:failed with blocked_by_dialog (carrying the dialog text) or no_evidence_captured rather than reporting done. Pass inlineFrames:true on the final fetch for base64 thumbnails a browser can render. restarts[] {at, why, kind} lists any restart the chain performed (only with allowRestart). prove.planned / prove.skipped say whether evidence frames were captured and why (AI threads bind only by default).",+      "timeoutSeconds": 20+    },+    {+      "example": {+        "limit": 20,+        "sections": "components,nets"+      },+      "input": {+        "expectDocument": "required: the board's name",+        "limit": "int: cap each list",+        "sections": "csv of components,nets,layers,copper,rules,occupancy,outline (default all)"+      },+      "longRunning": false,+      "name": "fusion_read_board",+      "output": {+        "counts": "{section.list: n}",+        "data": "{section: {...}}",+        "revision": "str",+        "roundtripMs": "int"+      },+      "statusVerb": null,+      "summary": "The standard's read_board: the live board in one round trip, as sections: components, nets (with net classes), layers (copper and stack-up), copper (tracks, arcs, vias, pads, pours), rules, occupancy (layers in use) and outline. sections picks some (csv); limit caps each list, with the full counts beside it.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "the board's name, for libId",+        "libId": "'Library:Package' from the board's embedded libraries",+        "libraryPath": "a .lbr on the Fusion machine (with name)",+        "name": "the package's name"+      },+      "longRunning": false,+      "name": "fusion_read_footprint",+      "output": {+        "attributes": "{mount}",+        "courtyardMm": "[x1, y1, x2, y2]",+        "graphics": "{layer: count}",+        "layers": "[str]",+        "models": "[{name, urn, type}]",+        "name": "str",+        "pads": "[{number, type, shape, at, sizeMm, drillMm, layers, rotation}]"+      },+      "statusVerb": null,+      "summary": "Every detail of one library footprint (the standard's read_footprint): pads with number, type, shape, position, size, drill, layers and turn; the layers used; the courtyard box (component exclude layers 39/40, else pads and placement outline); graphics per layer; the 3D packages that instance it. From a .lbr (libraryPath + name) or, by libId 'Lib:Name', from the libraries the open board embeds.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_read_rules",+      "output": {+        "count": "int",+        "params": "{mdWireWire:...}",+        "ruleSet": "str",+        "rules": "[{name,kind,enabled,priority,scope1,scope2,value,preferredValue,attrs,liveDrc,manualDrc}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Every design rule on the live board from Fusion's rule manager, disabled ones included: name, kind (Copper Clearance, Minimum Copper Width, Teardrop...), enabled, priority, both scopes, value and preferred value, whether live and manual DRC check its kind, plus the classic design-rule values (params) and the rule set's name.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "path": "C:/Users/me/Documents/board.sch"+      },+      "input": {+        "params": "bool, default false: every attribute with its value",+        "path": "required: EAGLE .sch or Fusion .fsch on the Fusion machine (alias filePath, schPath)",+        "pins": "bool, default true"+      },+      "longRunning": false,+      "name": "fusion_read_sheet_file",+      "output": {+        "complete": "bool (false with hierarchical modules or unknown devicesets)",+        "components": "[{designator,libReference,deviceset,device,comment,description,uniqueId,partNumber?,sourceLibrary,partCount,sheet,xMil,yMil,xMm,yMm,orientation,params?,pins:[{number,name,gate,electrical,direction}]}]",+        "count": "int",+        "elapsedMs": "int",+        "format": "str",+        "sheets": "int"+      },+      "statusVerb": null,+      "summary": "Read a schematic straight from its file, without Fusion running: every part of an EAGLE .sch (or the .sch inside a Fusion .fsch) with its designator, library reference (deviceset + device), value, description, part number, library, sheet, position and orientation, parameters on request, and its pins: number (the pad), name, gate and electrical type (input, output, io, open_collector, passive, hiz, power, supply, not_connected) for a schematic review. Milliseconds. The saved file, not the live sheet.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "symbolName": "LM358"+      },+      "input": {+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "symbolName": "str (required)"+      },+      "longRunning": false,+      "name": "fusion_read_symbol",+      "output": {+        "libref": "str",+        "models": "[{type, name}]",+        "params": "[{name, value}]",+        "pins": "[{des, name, gate, electrical, hidden}]"+      },+      "statusVerb": null,+      "summary": "Read a component of a .lbr back (the standard's read_symbol): description, its pins with number, name, gate and electrical type (0 input, 1 io, 2 output, 3 open collector, 4 passive, 5 hi-z, 7 power), its attributes and its footprints (devices).",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {},+      "longRunning": false,+      "name": "fusion_readiness",+      "output": {+        "bridgeVersion": "str",+        "hostApp": "str",+        "installed": "bool",+        "ready": "bool",+        "running": "bool"+      },+      "statusVerb": null,+      "summary": "FAST readiness check (does NOT launch Fusion): is the Fusion host app installed + running + the bridge ready to drive? ab DETECTS Fusion (never installs it) via bridge.json 'detect', and auto-installs Python if missing (ab >=1.9.47). Call this before driving Fusion; if installed-but-not-running, fusion_start. SELF-HEALS the seat/licensing dialog (background UIA + screenshot-verify) whenever it detects one. Pairs with ab's bridge_readiness.",+      "timeoutSeconds": 15+    },+    {+      "example": {},+      "input": {+        "save": "optional bool (default false): save open documents before closing"+      },+      "longRunning": false,+      "name": "fusion_release_seat",+      "output": {+        "released": "bool",+        "success": "bool",+        "wasHeldBy": "obj"+      },+      "statusVerb": null,+      "summary": "Give up the Autodesk seat from THIS machine so another box can claim it with no modal at all: closes Fusion cleanly (documents are NOT discarded; an unsaved one refuses and says so) and leaves the account signed in, so this box can claim the seat straight back. The counterpart of fusion_claim_seat.",+      "timeoutSeconds": 180+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "footprintName": "str",+        "libraryPath": "a .lbr on the Fusion machine"+      },+      "longRunning": false,+      "name": "fusion_remove_footprint",+      "output": {+        "removed": "str"+      },+      "statusVerb": null,+      "summary": "Delete a footprint from a .lbr (the standard's remove_footprint); refused while a component uses it.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "dryRun": true,+        "kinds": [+          "text"+        ],+        "layer": "F.SilkS"+      },+      "input": {+        "dryRun": "bool (lists ids)",+        "expectDocument": "required",+        "expectedRevision": "optional",+        "ids": "[id]",+        "kinds": "[line|arc|rect|circle|polygon|text|dimension]",+        "layer": "F.SilkS, B.SilkS, F.Fab, B.Fab, Edge.Cuts, a copper name or a Fusion layer number"+      },+      "longRunning": false,+      "name": "fusion_remove_graphics",+      "output": {+        "count": "int (dry run)",+        "removed": "[{id, kind, layer, points, text}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Remove board-level graphics (the standard's remove_graphics): lines, arcs, rectangles, circles, polygons, texts and dimensions, by id, or every one on a layer and/or of a kind. Fusion stores no ids: an id is kind:layer:points, and a dry run lists them. Each is picked with only its layer shown; the rest of the board must read back unchanged, or every DELETE is undone. Graphics inside parts are not touched.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "vias": [+          {+            "position": {+              "x": 12.5,+              "y": 8+            }+          }+        ]+      },+      "input": {+        "expectedRevision": "str from fusion_routing_state",+        "tracks": "[{start:{x,y}, end:{x,y}, layer}]",+        "vias": "[{position:{x,y}}]"+      },+      "longRunning": false,+      "name": "fusion_remove_items",+      "output": {+        "removed": "{tracks, vias}",+        "results": "[str]",+        "revision": "str",+        "success": "bool",+        "unconnected": "int"+      },+      "statusVerb": null,+      "summary": "Delete tracks and vias given exactly as fusion_routing_state returned them (track start, end, layer; via position). The board is read back as the old one minus exactly those items, or every removal is undone. results[] is per item: ok or err:not found.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "dryRun": true,+        "refs": [+          "R7",+          "R8"+        ]+      },+      "input": {+        "allowLocked": "bool, default false",+        "dryRun": "bool",+        "expectDocument": "required: the board's name",+        "expectedRevision": "optional",+        "refs": "[ref] (required)"+      },+      "longRunning": false,+      "name": "fusion_remove_parts",+      "output": {+        "failed": "[{ref, error}]",+        "removed": "[{ref, nets}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Remove placed parts by designator (the standard's remove_parts). Fusion keeps the board in step with the schematic and ignores a part deleted on the board, so the part is deleted in the design's schematic and leaves the board with it. Each removed part lists the nets its pads carried; a locked part is refused unless allowLocked. Tracks that met its pads stay.",+      "timeoutSeconds": 150+    },+    {+      "example": {},+      "input": {+        "boardId": "required",+        "expectDocument": "required exact board name",+        "expectedRevision": "required",+        "pours": "optional 'all' (default) or [{net, layer, points}]"+      },+      "longRunning": false,+      "name": "fusion_remove_pours",+      "output": {+        "left": "list",+        "removed": "int",+        "revision": "str",+        "success": "bool"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Delete pours (all of them, or the ones named by net, layer and outline) so a board can be poured again after a refine. Each DELETE picks the outline point farthest from every pad (refused if none is 1 mm clear), and the readback undoes everything if a part or a track changed.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "libraryPath": "a .lbr on the Fusion machine",+        "symbolName": "str"+      },+      "longRunning": false,+      "name": "fusion_remove_symbol",+      "output": {+        "removed": "str",+        "symbolsRemoved": "[str]"+      },+      "statusVerb": null,+      "summary": "Delete a component from a .lbr, and the symbols no other component uses (the standard's remove_symbol).",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_rename_footprint",+      "output": {+        "devicesUpdated": "int",+        "renamed": "str"+      },+      "statusVerb": null,+      "summary": "Rename a footprint in a .lbr (the standard's rename_footprint): every device that uses it and its 3D package instances follow.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_rename_symbol",+      "output": {+        "renamed": "str"+      },+      "statusVerb": null,+      "summary": "Rename a component in a .lbr (the standard's rename_symbol).",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "background": "transparent",+        "side": "iso"+      },+      "input": {+        "background": "default|transparent",+        "expectDocument": "optional: the design's name",+        "format": "png|jpg",+        "height": "int px, default 900",+        "outputPath": "the image on the Fusion machine (default %TEMP%/adom-render/board-<side>.<format>)",+        "perspective": "bool, default false",+        "quality": "basic (high, a ray-traced render, is refused)",+        "side": "top|bottom|left|right|front|back|iso, default top",+        "width": "int px, default 1600",+        "zoom": "number, default 1.0"+      },+      "longRunning": false,+      "name": "fusion_render_board_3d",+      "output": {+        "design": "str",+        "height": "int",+        "path": "str",+        "side": "str",+        "success": "bool",+        "width": "int"+      },+      "statusVerb": null,+      "summary": "A 3D picture of the board from one side (the standard's render_board_3d): Fusion's own view of the design's 3D PCB, fitted to the board, saved as an image without the user's tab changing (it is put back). Orthographic by default; transparent background available for png.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "baseline": "compare"+      },+      "input": {+        "baseline": "set|compare",+        "drawingSheet": "true (Fusion draws the frame as a part; false is refused)",+        "expectDocument": "optional",+        "name": "file stem, default schematic (a baseline is per name and sheet)",+        "outputDir": "folder on the Fusion machine (default %TEMP%/adom-schematic-renders)",+        "sheet": "int, default 1",+        "threshold": "percent of pixels, default 0.5 (compare)",+        "width": "int px, default 2000 (dpi is chosen from the drawn extent)"+      },+      "longRunning": false,+      "name": "fusion_render_schematic",+      "output": {+        "baseline": "path",+        "changedRegionMm": "[x1, y1, x2, y2] | null (compare)",+        "diffPng": "path | null (compare)",+        "dpi": "int",+        "driftPercent": "number (compare)",+        "extentMm": "[x0, y0, x1, y1]",+        "height": "int",+        "pass": "bool (compare)",+        "png": "path",+        "rendererChanged": "bool (compare)",+        "sizeChanged": "bool (compare)",+        "width": "int"+      },+      "statusVerb": null,+      "summary": "Render a schematic sheet to a PNG without opening a window, through Fusion's own EXPORT IMAGE, and keep visual baselines: baseline set stores the render, baseline compare renders at the baseline's width and reports the pixel drift, the changed region (mm on the sheet) and a diff image with the changed pixels in red.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "dryRun": true,+        "source": [+          "U1",+          "R1",+          "C1"+        ],+        "targets": [+          [+            "U2",+            "R2",+            "C2"+          ]+        ]+      },+      "input": {+        "anchor": "a ref from source (default the first)",+        "dryRun": "bool",+        "expectDocument": "required",+        "source": "[refs] of the placed channel (2 or more)",+        "targets": "[[refs], ...] each in the same order as source"+      },+      "longRunning": false,+      "name": "fusion_replicate_layout",+      "output": {+        "footprintMismatches": "[{ref, footprint, source, sourceFootprint}]",+        "moved": "int",+        "moves": "[{ref, x, y, rotation}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Copy one channel's placement to matching channels (the standard's replicate_layout): each target keeps its anchor part where it is and every other part takes the source's offset and turn from the anchor, turned by the anchors' rotation difference; a bottom part stays mirrored. One guarded move (fusion_move_parts: read back, undone on a mismatch); footprintMismatches names parts whose footprint differs from their source part. dryRun returns the moves.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_repour",+      "output": {+        "filledAreaByLayerMm2": "{layer:mm2}",+        "filledAreaByNetMm2": "{net:mm2}",+        "revision": "str",+        "unfilled": "[net]",+        "zones": "[...]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Refill every copper pour on the live board (Fusion's ratsnest pass, with hidden fills shown again) and read the poured copper back: filled area per layer and per net, pours that poured nothing, and each pour's fill.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "force": "optional bool default false - also discard MODIFIED Untitled docs"+      },+      "longRunning": false,+      "name": "fusion_reset_workspace",+      "output": {+        "closedByAddin": "list",+        "remaining": "list",+        "success": "bool",+        "untitledScratchClosed": "int"+      },+      "statusVerb": null,+      "summary": "Bring Fusion back to a clean slate between runs: closes named documents AND the Untitled scratch the library/bind flow leaves behind (page issue #59). Fusion always keeps ONE blank document alive, so a single remaining Untitled is correct rather than a failure. MODIFIED Untitled docs are left untouched unless force:true, because those can hold real unsaved work.",+      "timeoutSeconds": 90+    },+    {+      "example": {},+      "input": {+        "maxClicks": "optional int (default 3)"+      },+      "longRunning": false,+      "name": "fusion_resolve_seat_dialog",+      "output": {+        "clicks": "int",+        "resolved": "bool"+      },+      "statusVerb": null,+      "summary": "Readiness EXECUTOR (Rust port, Phase 3): detect + resolve the Autodesk seat/licensing modal ('Active Sessions Exceeded' / 'Suspend Remote Session') in the background, at most 3 UIA clicks per call, screenshot-verified. Idempotent: nothing up answers clicks:0. fusion_readiness calls this itself when it sees the dialog; call it directly only when you are driving the launch by hand.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "save": true+      },+      "input": {+        "save": "optional bool (default true) - save open documents before restarting"+      },+      "longRunning": false,+      "name": "fusion_restart_for_addin",+      "output": {+        "addinReady": "bool",+        "steps": "[{step, ok}]",+        "success": "bool",+        "tookSec": "float"+      },+      "statusVerb": null,+      "summary": "ASYNC: returns immediately (started:true) and restarts Fusion in the background, SAVING the user's open documents first; poll fusion_readiness until ready with the new addinVersion (a restart takes 60-120s, longer than the relay budget; pass wait:true for the old blocking form). Finish add-in setup by restarting Fusion. Call this when any verb returns errorCode addin_restart_required (the add-in was installed/updated while Fusion was already open, and Fusion only loads add-ins at launch). A busy add-in (errorCode fusion_addin_busy, readiness addinBusy) is NOT a reason: it is loaded and working. ASK THE USER FIRST when a human is present - the failing verb's payload carries userMessage plus openDocuments/unsavedDocuments so you can show them what is open. Refuses with unsaved_named_document rather than discarding a never-saved document, and with restart_needs_decision (nothing killed or discarded) when Fusion asks to save work the bridge did not make; restartPolicy force (an AI-only machine) discards and kills instead.",+      "timeoutSeconds": 300+    },+    {+      "example": {},+      "input": {+        "expectDocument": "required: the board's name",+        "referenceNets": "[net] (default the nets that own pours)",+        "resolutionMm": "number"+      },+      "longRunning": false,+      "name": "fusion_return_path",+      "output": {+        "apply": "{verb: fusion_apply_pours, args}",+        "engine": "str",+        "findings": "[...]",+        "ok": "bool"+      },+      "statusVerb": null,+      "summary": "Signal tracks running over a gap in the neighbouring layer's reference copper, with a pour plan that closes each gap (apply as fusion_apply_pours): the shared checks engine on the live board, its stack-up and Fusion's pour fills.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "checks": "[check] (default all)",+        "edgeMm": "default 0.5",+        "expectDocument": "required: the board's name",+        "gridMm": "placement grid for the off-grid check"+      },+      "longRunning": false,+      "name": "fusion_review_board",+      "output": {+        "counts": "{error, warning, info}",+        "engine": "str",+        "findings": "[{check, severity, ...}]",+        "notImplemented": "[...]",+        "ran": "[check]",+        "skipped": "[...]"+      },+      "statusVerb": null,+      "summary": "Design-review checks over one read of the board (the standard's review_board), from the shared checks engine: thirteen checks, errors first; skipped and notImplemented name what was not judged. With the schematic's parts (fusion_schematic_data) for the checks that need them; the off-grid check runs only with gridMm.",+      "timeoutSeconds": 150+    },+    {+      "example": {},+      "input": {+        "boardId": "required",+        "expectDocument": "required exact board name",+        "expectedRevision": "required",+        "nets": "required [net name]"+      },+      "longRunning": false,+      "name": "fusion_ripup_nets",+      "output": {+        "revision": "str",+        "ripped": "[net]",+        "success": "bool",+        "verified": "bool"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Take whole nets' tracks and vias back up (RIPUP per net, one undo step each) so they can be routed again, wider or another way. Their pours stay. Readback proves no track or via is left on those nets and no pour was lost.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "allowSplit": "bool: keep a route that splits another net",+        "boardId": "required from routing_state",+        "clearance": "mm, can only raise the board's rules",+        "dryRun": "optional bool",+        "expectDocument": "required exact board name",+        "expectedRevision": "required from routing_state",+        "layer": "the first copper layer, by name or number; default F.Cu",+        "net": "required exact name",+        "paths": "optional list of paths instead of points",+        "points": "waypoints [x,y] or {pad} or {x,y,layer}; a waypoint's layer is the layer after it (a via where it changes)",+        "viaDiameter": "mm, default .6 (viaSize also works: fusion_plan_route's routeNet)",+        "viaDrill": "mm, default .3",+        "width": "mm, default .25"+      },+      "longRunning": false,+      "name": "fusion_route_net",+      "output": {+        "mutated": "bool",+        "plan": "obj",+        "remainingNets": "list",+        "revision": "str",+        "splitNets": "[net] (splits_net)",+        "success": "bool",+        "verified": "bool"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Create explicit net copper in the live Fusion canvas, on any copper layer of the board (F.Cu, In1.Cu ... B.Cu, or EAGLE's numbers). Clearance preflight against pads by their real outline, tracks and arcs, vias, holes (footprint mounting holes too), footprint and board copper and keepouts (tRestrict/bRestrict), with board/revision guards and exact copper readback. Pours are repoured round the new copper; a route that cuts another net's pour in two is undone (splits_net) unless allowSplit. One or several paths per call; no general autorouting. Use routing_drc for native DRC.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "from": {+          "neg": "IC1.7",+          "pos": "IC1.6"+        },+        "neg": "D_N",+        "pos": "D_P",+        "to": {+          "neg": "MP13.P$1",+          "pos": "MP14.P$1"+        }+      },+      "input": {+        "diffOhms": "target impedance instead of gap",+        "expectDocument": "required: the board's name",+        "fanMm": "escape length from the pads",+        "from": "{pos, neg} pads (Ref.Pad)",+        "gap": "mm",+        "layer": "copper layer",+        "neg": "negative net",+        "pos": "positive net",+        "to": "{pos, neg} pads",+        "via": "[[x, y]] waypoints",+        "width": "mm"+      },+      "longRunning": false,+      "name": "fusion_route_pair",+      "output": {+        "engine": "str",+        "problems": "[...]",+        "revision": "str",+        "routeNet": "[fusion_route_net arguments, one per net]",+        "skewMm": "number",+        "widthRule": "fusion_add_rule arguments"+      },+      "statusVerb": null,+      "summary": "Plan a differential pair routed as a pair (the standard's route_pair), from the shared checks engine: one centreline from the source pads' midpoint through waypoints to the destination pads' midpoint, each net offset to its side at width + gap (or the gap for diffOhms from the stack-up), with mitred corners. Answers routeNet [pos, neg] as fusion_route_net arguments, widthRule for fusion_add_rule and skewMm; problems lists crossings and other copper closer than the clearance, and while there are any success is false.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "boardId": "required",+        "expectDocument": "required exact board name",+        "expectedRevision": "required"+      },+      "longRunning": false,+      "name": "fusion_routing_drc",+      "output": {+        "drc": "{checked,clean,errorCount,warningCount,airwireCount,errors}",+        "revision": "str"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Run fresh native Autodesk DRC and read UL_BOARD.errors, including approved errors, warnings and airwires. Does not accept or clear any violation.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional document creationId guard",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_routing_state",+      "output": {+        "arcs": "[{center,radius,startAngle,endAngle,width,layer,net}]",+        "boardId": "str",+        "components": "[{ref,x,y,rotation,side,pattern,has3d}]",+        "copperLayers": "[F.Cu..B.Cu]",+        "fusionAirwires": "int, Fusion's own ratsnest",+        "model": "'eda-bridge-standard/board 0.1'",+        "nets": "[name]",+        "outline": "[[x,y]] (arcs sampled every 2 degrees)",+        "outlineEdges": "[{kind:line|arc,start,end,center?,radius?,angle1?,angle2?}]",+        "pads": "[{ref,name,key,x,y,sizeX,sizeY,rotation,layer,drill,net,shape,customShape?}]",+        "polygons": "[{net,layer,points}]",+        "remainingNets": "list (AI flow)",+        "revision": "str",+        "segments": "list (AI flow)",+        "splitNets": "[{net,groups}]",+        "tracks": "[{start,end,width,layer,net}]",+        "unconnected": "int from the copper",+        "units": "mm",+        "vias": "[{position,size,drill,layers,net}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Read the live board as the EDA Bridge Standard's board model, from a fresh Fusion export in the background: millimetres in Fusion's board frame, copper layers named F.Cu / In1.Cu / B.Cu, tracks, arcs (center, radius, angles), vias, every pad with its size, shape, rotation and net (a custom-shape pad as its bounding rectangle), parts with side and footprint, pours, net-less copper kept with an empty net, the outline as edges with its arcs, and unconnected / splitNets computed from the copper itself. The revision changes only with copper, parts or outline: edit verbs take it back as expectedRevision. Also carries the AI flow's keys (segments, elements, airwireCount, remainingNets, each pad's key REF.PAD).",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_rules_by_kind",+      "output": {+        "ruleSet": "str",+        "rulesByKind": "{kind:[rule]}"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The ENABLED design rules grouped by kind, each group in priority order.",+      "timeoutSeconds": 60+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_execute_text_command"+      },+      "longRunning": false,+      "name": "fusion_run_command",+      "output": {+        "...": "as fusion_execute_text_command",+        "aliasOf": "fusion_execute_text_command"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_execute_text_command: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name",+        "limit": "int, default 200 violations"+      },+      "longRunning": false,+      "name": "fusion_run_drc",+      "output": {+        "airwires": "int",+        "errors": "int",+        "summary": "{rule: n}",+        "violationCount": "int",+        "violations": "[{rule,code,severity,layer,at:[x,y],approved}]",+        "warnings": "int"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Run Fusion's own design rule check on the live board in the background and read every violation back: rule text, error or warning, layer, position in mm, approved or not, plus counts by rule. No revision guard: it changes no copper, parts or outline, but Fusion stores the DRC result in the board, so the document then reads as modified (close it without saving if you only looked). fusion_routing_drc is the same check inside the routing guards.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "the board's name"+      },+      "longRunning": false,+      "name": "fusion_run_erc",+      "output": {+        "byClass": "{error, warning}",+        "byCode": "{code: count}",+        "errorCount": "int",+        "messageCount": "int",+        "messages": "[{class, source, document, text, code, sheet, x, y, approved}]",+        "success": "bool",+        "warningCount": "int"+      },+      "statusVerb": null,+      "summary": "Fusion's own ERC on the open board's schematic: the design's schematic tab is brought forward for the check and the board's put back; every message is read from Fusion (UL_SCHEMATIC.errors) with its class, code, sheet and position. No dialog.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "script": "import adsk.fusion\n# ...build geometry..."+      },+      "input": {+        "script": "required str (Python using adsk; globals: adsk, app, ui, design)"+      },+      "longRunning": true,+      "name": "fusion_run_modeling_script",+      "output": {+        "documentName": "str",+        "result": "obj"+      },+      "statusVerb": null,+      "summary": "Run an adsk.fusion modeling script in the live session (sketches/extrudes/params). Free programmatic CAD.",+      "timeoutSeconds": 180+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_run_modeling_script"+      },+      "longRunning": false,+      "name": "fusion_run_script",+      "output": {+        "...": "as fusion_run_modeling_script",+        "aliasOf": "fusion_run_modeling_script"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_run_modeling_script: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "...": "as fusion_save_document"+      },+      "longRunning": false,+      "name": "fusion_save",+      "output": {+        "...": "as fusion_save_document",+        "aliasOf": "fusion_save_document"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_save_document: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "comment": "routed the power nets"+      },+      "input": {+        "comment": "optional version comment",+        "documentName": "optional: the design's name (default the active document)"+      },+      "longRunning": false,+      "name": "fusion_save_document",+      "output": {+        "files": "{...}",+        "linkedBoard": "{name, ext, fileId, version, project, folder}",+        "saved": "bool",+        "success": "bool",+        "versions": "{design, schematic, board, 3dPcb: {before, after}}"+      },+      "statusVerb": null,+      "summary": "Save the open electronics design IN PLACE as a new version (no Save As, no fork): resolves the design behind whichever tab is in front (or documentName), saves it, and reads back each changed document's version before and after, the board the design links, and keeps the 3D PCB beside the design. Answers saved:false when Fusion reports nothing unsaved, and not_saved_yet for a design that was never saved (use fusion_save_to_cloud for that first save).",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "name": "TJA1050",+        "projectName": "Main"+      },+      "input": {+        "asCopy": "optional bool: a separate copy of an already-saved design",+        "description": "optional str",+        "folderPath": "optional str, created if missing",+        "name": "required str",+        "overwrite": "optional bool",+        "projectName": "str (required when no project is open in Fusion's data panel)"+      },+      "longRunning": false,+      "name": "fusion_save_to_cloud",+      "output": {+        "files": "{design, schematic, board, 3dPcb: {name, ext, fileId, version, project, folder}}",+        "foldersCreated": "[str]",+        "success": "bool",+        "urn": "str (mechanical)"+      },+      "statusVerb": null,+      "summary": "First save of the ACTIVE document to Autodesk cloud storage with an explicit name and destination, dialog-free. On an electronics design it saves the DESIGN (.fprj with its .fsch and .fbrd, linked; the 3D PCB beside them), whichever of its tabs is in front, and puts the same kind of tab back in front. A design that is already saved is REFUSED (already_saved_use_save_document: a Save As by name forks the board into an unlinked .fbrd) unless asCopy:true. Missing folders on folderPath are created; a name already in the folder is refused unless overwrite:true. A mechanical document is saved as before.",+      "timeoutSeconds": 240+    },+    {+      "example": {+        "label": "D[0..7]",+        "points": [+          [+            20,+            100+          ],+          [+            80,+            100+          ]+        ]+      },+      "input": {+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "label": "str",+        "points": "[[x, y], ...] (required)",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_bus",+      "output": {+        "ids": "[bus id]",+        "label": "str|null",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Draw a bus as a polyline, optionally named by a bus label at its first point (D[0..7], or a group such as {SDA SCL}). Read back, or undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "entries": [+          {+            "at": [+              40,+              102.54+            ],+            "direction": "down-right"+          }+        ]+      },+      "input": {+        "dryRun": "bool, default false",+        "entries": "[{at: [x, y] (the wire end), direction?: down-right|up-right|down-left|up-left, member?: str, sizeMm?: 2.54}] (required)",+        "expectDocument": "optional",+        "expectedRevision": "str",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_bus_entry",+      "output": {+        "added": "[{id, at, end, onBus, member}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Add 45-degree bus entries: the short diagonal from a member wire's end onto a bus. In Fusion an entry is a net wire named for its bus member (drawn from the bus side, so no member menu opens); member defaults to the net of the wire ending at at. Refused with entry_off_bus when the entry misses the bus, not_a_member when the net is not in the bus. Read back, or undone.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "connections": [+          {+            "designator": "U2",+            "kind": "power",+            "net": "GND",+            "pin": "1"+          },+          {+            "designator": "U2",+            "net": "VIN",+            "pin": "VIN"+          }+        ]+      },+      "input": {+        "connections": "[{designator, pin (pad number or name), net, kind?: label|power|port|wire, stubMil?}] (required)",+        "dryRun": "bool",+        "expectDocument": "the design",+        "sheet": "int, default the one shown"+      },+      "longRunning": false,+      "name": "fusion_sch_connect",+      "output": {+        "connected": "int",+        "failed": "[{designator, pin, error, code}]",+        "results": "[{designator, pin, net, kind, result, endMil}]",+        "saved": "false"+      },+      "statusVerb": null,+      "summary": "Connect pins of placed parts (the standard's sch_connect): per connection a stub from the pin's outer end (stubMil, default 200) named for the net and a label at its end (kind label; port: an XREF label; power: a label too, as Fusion's power symbols are library parts and nets join by name); kind wire is the named stub alone. A pin already on another net is refused, never merged; noerc is refused (Fusion has no No-ERC marker). Read back; a mismatch undoes every command.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "pairs": [+          {+            "from": "U1.1",+            "to": "R2.1"+          }+        ]+      },+      "input": {+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "pairs": "[{from: \"U1.1\", to: \"R5.2\", first?: h|v, via?: [[x, y]]}] (required)",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_connect_pins",+      "output": {+        "failed": "[{from, to, error}]",+        "junctionsAdded": "[[x, y]]",+        "revision": "str",+        "routes": "[{from, to, points, net, merged}]",+        "wired": "int"+      },+      "statusVerb": null,+      "summary": "Wire pins to pins by Ref.Pin (matched by pad number, then pin name): one L-shaped route per pair (first leg along the from pin, or first:h|v, through via points), drawn as one net wire. Pins on two named nets join them (Fusion's 'Connect A and B?' is answered on the command line, and merged lists them). A route corner or end landing on another wire's middle gets a junction. Read back: each pair must end on one net, or everything is undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "pins": [+          "U1.1",+          "U1.2"+        ],+        "prefix": "D",+        "start": 0+      },+      "input": {+        "bus": "bus id or name (default the only bus)",+        "busLabel": "bool|str: also label the bus",+        "dryRun": "bool, default false",+        "entry": "up|down (vertical bus) or left|right (horizontal bus)",+        "expectDocument": "optional",+        "expectedRevision": "str",+        "members": "[str]",+        "pins": "[Ref.Pin] in member order (required)",+        "prefix": "str, default D",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1",+        "start": "int, default 0"+      },+      "longRunning": false,+      "name": "fusion_sch_connect_to_bus",+      "output": {+        "busLabel": "str|null",+        "connected": "[{pin, member, wireId, entryId}]",+        "failed": "[{pin, error}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Fan pins onto a bus: per pin, a wire from the pin to beside the bus, a 45-degree entry onto it and a member label, the net named for the member (members in pin order, or prefix plus start). Only an unconnected pin, or one already on that member net, is wired; one on another net is listed in failed (wiring it would join two nets). Read back: each pin on its member net, or undone.",+      "timeoutSeconds": 180+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool, default false",+        "expectDocument": "optional",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int: must be the next number (default it)"+      },+      "longRunning": false,+      "name": "fusion_sch_create",+      "output": {+        "created": "bool",+        "page": "int",+        "revision": "str",+        "sheet": "int",+        "sheetSymbol": "null"+      },+      "statusVerb": null,+      "summary": "Add an empty sheet after the last one (Fusion numbers a schematic's sheets; it has no sheet files). Page and child-sheet arguments are refused: Fusion sets a page through a frame part, and a child sheet is a module. Read back, or undone.",+      "timeoutSeconds": 150+    },+    {+      "example": {+        "ids": [+          "wire:40.64,127,40.64,132.08"+        ]+      },+      "input": {+        "at": "[x, y]",+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "from": "[x, y]",+        "ids": "[wire id]",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1",+        "to": "[x, y]"+      },+      "longRunning": false,+      "name": "fusion_sch_delete_wire",+      "output": {+        "deleted": "[wire id]",+        "junctionsRemoved": "[[x, y]]",+        "notFound": "[str]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Delete schematic wires by id, by their two ends, or every wire through a point; junctions left joining fewer than three items are removed too. Every other wire must read back unchanged, or the delete is undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "dryRun": true,+        "edits": [+          {+            "action": "rotate",+            "degrees": 90,+            "designator": "R1"+          }+        ]+      },+      "input": {+        "dryRun": "bool",+        "edits": "[{designator, action, x,y | dx,dy | degrees | to | text}] (required)",+        "expectDocument": "the design",+        "sheet": "default the one shown"+      },+      "longRunning": false,+      "name": "fusion_sch_edit",+      "output": {+        "applied": "int",+        "failed": "[..]",+        "results": "[{designator, check, result}]"+      },+      "statusVerb": null,+      "summary": "Change placed parts on a sheet (the standard's sch_edit): move (x, y mil), moveBy (dx, dy mil), rotate (degrees), designator (rename, the board follows), comment (value), delete. Each is read back; a mismatch undoes the edit.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "edits": [+          {+            "by": [+              0,+              2.54+            ],+            "net": "SDA"+          }+        ]+      },+      "input": {+        "dryRun": "bool, default false: answer the plan and change nothing",+        "edits": "[{id | at | net, moveTo?: [x, y], by?: [dx, dy], rotation?: deg, rename?: str}] (required)",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_edit_label",+      "output": {+        "edited": "[{id, net, to, rotation, rename}]",+        "failed": "[{edit, error}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Edit net labels by id, point or a whole net: move to a point or by a delta, set the rotation, or rename (a label shows its net's name, so a rename renames the label's wire segment; other segments of the old net keep their name; onto an existing name the two join, which Fusion asks about and the bridge answers on the command line). Read back, or undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "toleranceMm": 0.5+      },+      "input": {+        "dryRun": "bool, default TRUE",+        "expectDocument": "optional",+        "expectedRevision": "str",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1",+        "toleranceMm": "default 0.5"+      },+      "longRunning": false,+      "name": "fusion_sch_fix_connectivity",+      "output": {+        "moves": "[{net, from, to, distanceMm}]",+        "revision": "str",+        "unresolved": "[{net, at, why}]"+      },+      "statusVerb": null,+      "summary": "Find wire ends that almost touch a pin, label or other wire end (within toleranceMm) and, with dryRun:false, move each onto it. dryRun defaults to true: it lists the moves and changes nothing.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "optional",+        "filePath": "optional .sch/.fsch"+      },+      "longRunning": false,+      "name": "fusion_sch_hierarchy",+      "output": {+        "duplicatePages": "[]",+        "modules": "[str]",+        "problems": "[str]",+        "renumbered": "false",+        "tree": "{name, sheets: [{page, description, children: [{name, module, path, at, sizeMm, pins, sheets}]}]}"+      },+      "statusVerb": null,+      "summary": "The design's sheet tree: the root sheets in order, and under each the module instances placed on it (Fusion's sheet symbols), each with its module's ports as pins and its own sheets, recursively. Read only; renumber is refused (Fusion numbers sheets by their order).",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "kinds": [+          "wires",+          "labels"+        ],+        "sheet": 1+      },+      "input": {+        "expectDocument": "optional: the design's name",+        "filePath": "optional .sch/.fsch on the Fusion machine instead of the open design",+        "kinds": "[wires, buses, busEntries, labels, powerPorts, junctions, noConnects, texts, sheets] (default all)",+        "sheet": "int, default 1 (Fusion numbers a schematic's sheets; or the sheet's description)"+      },+      "longRunning": false,+      "name": "fusion_sch_items",+      "output": {+        "busEntries": "[{id, net, at, end}]",+        "buses": "[{id, bus, from, to}]",+        "counts": "{kind: int}",+        "junctions": "[{id, net, at}]",+        "labels": "[{id, text, kind, at, rotation}]",+        "noConnects": "[] (EAGLE marks an unused pin by its type, not a marker)",+        "powerPorts": "[{id, ref, net, at}]",+        "revision": "str",+        "sheetCount": "int",+        "sheets": "[{id, name, module, at, sizeMm}]",+        "texts": "[{id, text, at, sizeMm, rotation}]",+        "wires": "[{id, net, from, to}]"+      },+      "statusVerb": null,+      "summary": "List one schematic sheet's wiring items with ids and positions (mm, y up): wires, buses, bus entries, net labels (local, global, hierarchical), power ports, junctions, texts and module instances (Fusion's sheet symbols). Read from Fusion's own export of the design's schematic, whichever tab is in front (the tab is put back), or from a .sch/.fsch on the Fusion machine. Fusion stores no ids, so each id is the item's kind and position. Read only.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "points": [+          [+            40.64,+            132.08+          ]+        ]+      },+      "input": {+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "force": "bool, default false",+        "points": "[[x, y]]",+        "remove": "[id | [x, y]]",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_junction",+      "output": {+        "added": "[[x, y]]",+        "notNeeded": "[[x, y]]",+        "removed": "[[x, y]]",+        "revision": "str",+        "skipped": "[{at, why}]"+      },+      "statusVerb": null,+      "summary": "Add junction dots at points, or remove dots by id or point. A point no wire passes is skipped; one where fewer than three items meet is listed as notNeeded and left (force:true adds it anyway). Read back, or undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "box": [+          0,+          0,+          50,+          50+        ],+        "by": [+          10,+          0+        ]+      },+      "input": {+        "box": "[x1, y1, x2, y2] mm (required)",+        "by": "[dx, dy] mm (required)",+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_move_region",+      "output": {+        "boxUsed": "[x1, y1, x2, y2]: the box on the sheet grid",+        "moved": "{parts, by}",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Move everything inside a box by (dx, dy) as one group: parts, wires, labels, junctions and texts; wires on the pins of a moved part follow it, and wires crossing the edge stretch. Fusion snaps the outline of a group to the sheet grid, so the box is snapped first (boxUsed) and refused with box_edge_off_grid, naming the parts, when the snapped box would take different parts than the asked one. Read back: parts, texts and labels moved exactly, nothing outside moved, every pin on the net it was on; otherwise undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "optional",+        "filePath": "optional .sch/.fsch",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_page",+      "output": {+        "changed": "false",+        "frame": "{ref, symbol, rect}|null",+        "heightMm": "number|null",+        "orientation": "landscape|portrait|null",+        "paper": "A4|A3|...|A|B|C|D|E|null",+        "titleBlock": "{title, rev, date, company, attributes}",+        "widthMm": "number|null"+      },+      "statusVerb": null,+      "summary": "A schematic sheet's page: the frame Fusion draws it in (paper size, orientation, rectangle) and the title block fields from the design's attributes. Reading only for now: setting the page is refused with unsupported.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "references": [+          "U1"+        ]+      },+      "input": {+        "connections": "bool, default true",+        "expectDocument": "optional",+        "filePath": "optional .sch/.fsch",+        "references": "[ref] (default every part)",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_pins",+      "output": {+        "count": "int",+        "pins": "[{ref, gate, pin, number, at, side, electrical, net, wires, labels, connectedPins}]",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Every pin of the named parts (or all) on a schematic sheet: its connection point (rotation and mirror applied), symbol pin name, the pad number(s) it maps to, electrical type, the side it leaves the body, its net, and the wires, labels and pins on its wire segment. Read only.",       "timeoutSeconds": 60     },     {       "example": {-        "save": true+        "comment": "10k",+        "designator": "R?",+        "library": "C:/parts/Lib.lbr",+        "symbol": "R-US",+        "x": 3000,+        "y": 4000       },       "input": {-        "save": "optional bool (default true) - save open documents before restarting"+        "comment": "the value",+        "designator": "e.g. R12 or R? (default the deviceset's prefix, next free)",+        "dryRun": "bool",+        "expectDocument": "the design",+        "footprint": "a package name of the deviceset's variants",+        "library": ".lbr path on the Fusion machine (required)",+        "rotation": "0|90|180|270",+        "sheet": "int, default the one shown",+        "symbol": "the deviceset (required)",+        "x": "mil, default 1000",+        "y": "mil, default 1000"       },       "longRunning": false,-      "name": "fusion_restart_for_addin",+      "name": "fusion_sch_place_part",       "output": {-        "addinReady": "bool",-        "steps": "[{step, ok}]",-        "success": "bool",-        "tookSec": "float"+        "atMil": "[x, y]",+        "designator": "str",+        "footprints": "[package]",+        "libref": "dev@lib",+        "pins": "int",+        "saved": "false"       },       "statusVerb": null,-      "summary": "ASYNC: returns immediately (started:true) and restarts Fusion in the background, SAVING the user's open documents first; poll fusion_readiness until ready with the new addinVersion (a restart takes 60-120s, longer than the relay budget; pass wait:true for the old blocking form). Finish add-in setup by restarting Fusion. Call this when any verb returns errorCode addin_restart_required (the add-in was installed/updated while Fusion was already open, and Fusion only loads add-ins at launch). ASK THE USER FIRST when a human is present - the failing verb's payload carries userMessage plus openDocuments/unsavedDocuments so you can show them what is open. Refuses with unsaved_named_document rather than discarding a never-saved document.",-      "timeoutSeconds": 300+      "summary": "Place a part on the schematic (the standard's sch_place_part): a deviceset from a .lbr on the Fusion machine at x, y (mil) and a rotation, with its designator (R? or none: the next free number) and value (comment). footprint picks the variant whose package has that name. The device is proven in the .lbr and the library USEd first, and ADD's questions are answered, so no picker or dialog opens; read back as the one part added, or undone. Fusion adds it to the board too.",+      "timeoutSeconds": 120     },     {-      "example": {},+      "example": {+        "references": [+          "R5",+          "C3"+        ]+      },       "input": {-        "boardId": "required",-        "expectDocument": "required exact board name",-        "expectedRevision": "required",-        "nets": "required [net name]"+        "all": "bool: every part on the sheet",+        "dryRun": "bool, default false",+        "expectDocument": "optional",+        "expectedRevision": "str",+        "fields": "[designator, value] by default; other attribute names as Fusion names them",+        "references": "[ref]",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"       },       "longRunning": false,-      "name": "fusion_ripup_nets",+      "name": "fusion_sch_reset_fields",       "output": {+        "reset": "[{ref, field}]",         "revision": "str",-        "ripped": "[net]",-        "success": "bool",-        "verified": "bool"+        "untouched": "[{ref, field, why}]"       },-      "statusVerb": "fusion_routing_state",-      "summary": "Take whole nets' tracks and vias back up (RIPUP per net, one undo step each) so they can be routed again, wider or another way. Their pours stay. Readback proves no track or via is left on those nets and no pour was lost.",-      "timeoutSeconds": 120+      "statusVerb": null,+      "summary": "Put parts' designator and value text (or other named fields) back where the library symbol places them, through each part's turn and mirror: position, rotation and alignment; size and visibility stay. A field that is not smashed is already there and is listed as untouched. Read back, or undone.",+      "timeoutSeconds": 150     },     {-      "example": {},+      "example": {+        "validate": true+      },       "input": {-        "boardId": "required from routing_state",-        "clearance": "mm lower bound, default .2",-        "dryRun": "optional bool",-        "expectDocument": "required exact board name",-        "expectedRevision": "required from routing_state",-        "layer": "1 or 16, default 1",-        "net": "required exact name",-        "paths": "optional list of paths instead of points",-        "points": "waypoints [x,y] or {pad} or {x,y,layer}",-        "viaDiameter": "mm, default .6",-        "viaDrill": "mm, default .3",-        "width": "mm, default .25"+        "action": "list (others refused)",+        "expectDocument": "optional",+        "filePath": "optional .sch/.fsch",+        "sheet": "int, default 1",+        "sheetSymbol": "module instance name (default every one)",+        "validate": "bool"       },       "longRunning": false,-      "name": "fusion_route_net",+      "name": "fusion_sch_sheet_pins",       "output": {-        "mutated": "bool",-        "plan": "obj",-        "remainingNets": "list",-        "revision": "str",-        "success": "bool",-        "verified": "bool"+        "added": "[]",+        "pins": "[{id, sheetSymbol, name, kind, side, coord, connected}]",+        "problems": "[{sheetSymbol, pin, problem}]"       },-      "statusVerb": "fusion_routing_state",-      "summary": "Create explicit net copper in the live Fusion canvas. Conservative clearance preflight, board/revision guards and exact copper readback. One or several trace segments per call; no general autorouting. Use routing_drc for native DRC.",-      "timeoutSeconds": 120+      "statusVerb": null,+      "summary": "A sheet symbol's pins: in Fusion a sheet symbol is a module instance and its pins are the module's ports. Lists them with kind, side and whether a net reaches each; validate lists the unwired ones. Adding, renaming or deleting is refused (that is the module's PORT edit).",+      "timeoutSeconds": 90     },     {-      "example": {},+      "example": {+        "at": [+          30,+          132.08+        ]+      },       "input": {-        "boardId": "required",-        "expectDocument": "required exact board name",-        "expectedRevision": "required"+        "at": "[x, y] (the cut; default the middle of id)",+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "id": "wire id",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1"       },       "longRunning": false,-      "name": "fusion_routing_drc",+      "name": "fusion_sch_split_wire",       "output": {-        "drc": "{checked,clean,errorCount,warningCount,airwireCount,errors}",+        "ids": "[two wire ids]",+        "junction": "id",         "revision": "str"       },-      "statusVerb": "fusion_routing_state",-      "summary": "Run fresh native Autodesk DRC and read UL_BOARD.errors, including approved errors, warnings and airwires. Does not accept or clear any violation.",+      "statusVerb": null,+      "summary": "Split a schematic wire at a point into two wires with a junction dot at the cut (Fusion's way: a junction on a wire splits it), so a branch can end on a wire end. junction:false is refused.",       "timeoutSeconds": 120     },     {       "example": {-        "expectDocument": "fusion-routing"+        "designator": "C10",+        "footprint": "CAPC1005X60",+        "library": "C:/parts/Lib.lbr",+        "symbol": "C"       },       "input": {-        "boardId": "optional document creationId guard",-        "expectDocument": "required exact active board name"+        "designator": "required",+        "dryRun": "bool",+        "expectDocument": "the design",+        "footprint": "package of the variant",+        "keepComment": "bool, default false",+        "library": ".lbr path (required)",+        "symbol": "the new deviceset (required)"       },       "longRunning": false,-      "name": "fusion_routing_state",+      "name": "fusion_sch_swap_part",       "output": {-        "boardId": "str",-        "nets": "list",-        "pads": "list",-        "remainingNets": "list",+        "lostConnections": "[{pin, net}]",+        "newPinsNotOnOld": "[pad]",+        "now": "{libReference, footprints}",+        "oldPinsNotOnNew": "[pad]",+        "pinsJoined": "[] (Fusion does not add wires)"+      },+      "statusVerb": null,+      "summary": "Replace a placed part's device (the standard's sch_swap_part) with EAGLE's REPLACE: same name, place and turn, a deviceset from a .lbr on the Fusion machine (footprint picks the variant). Fusion keeps the connections of pins that land where the old ones were; the reply compares every pin's net by pad number and lists lostConnections to wire with fusion_sch_connect. keepComment puts the old value back. Multi-gate devices are refused. Read back, or undone.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "texts": [+          {+            "at": [+              20,+              150+            ],+            "text": "Power input"+          }+        ]+      },+      "input": {+        "dryRun": "bool, default false: answer the plan and change nothing",+        "expectDocument": "optional: the design's name",+        "expectedRevision": "the revision you last read (refused with stale_schematic otherwise)",+        "save": "bool, default FALSE: each Fusion save is a new cloud version; true saves the design after the edit (as fusion_save_document)",+        "sheet": "int, default 1",+        "texts": "[{text, at: [x, y], sizeMm?: 1.778, angle?: 0, align?: bottom-left|center|...}] (required)"+      },+      "longRunning": false,+      "name": "fusion_sch_text",+      "output": {+        "added": "int",         "revision": "str",-        "segments": "list",-        "vias": "list"+        "texts": "[{id, text, at}]"       },-      "statusVerb": "fusion_routing_state",-      "summary": "Read the live board's identity, geometry revision, pads, copper and per-net airwires from a fresh Fusion export.",-      "timeoutSeconds": 60+      "statusVerb": null,+      "summary": "Add free text to a schematic sheet (a note, a title): size, angle and alignment, on the Info layer. Read back exactly, or undone.",+      "timeoutSeconds": 120     },     {       "example": {-        "script": "import adsk.fusion\n# ...build geometry..."+        "at": [+          40.64,+          132.08+        ]       },       "input": {-        "script": "required str (Python using adsk; globals: adsk, app, ui, design)"+        "at": "[x, y] mm (required)",+        "expectDocument": "optional",+        "filePath": "optional .sch/.fsch",+        "sheet": "int, default 1",+        "toleranceMm": "default 0.01"       },-      "longRunning": true,-      "name": "fusion_run_modeling_script",+      "longRunning": false,+      "name": "fusion_sch_trace_point",       "output": {-        "documentName": "str",-        "result": "obj"+        "crossingWithoutJunction": "bool",+        "items": "[{kind, id, net}]",+        "nearest": "{kind, id, net, distanceMm} | null",+        "nets": "[{name, bus, pins, sheets}]"       },       "statusVerb": null,-      "summary": "Run an adsk.fusion modeling script in the live session (sketches/extrudes/params). Free programmatic CAD.",-      "timeoutSeconds": 180+      "summary": "Everything electrically joined at one point of a schematic sheet: the wires, junctions, labels and pins there, and each net they belong to in full (its pins and the sheets it is on). crossingWithoutJunction is true when wires of two nets meet there without connecting. Nothing there gives the nearest item. Read only.",+      "timeoutSeconds": 60+    },+    {+      "example": {},+      "input": {+        "expectDocument": "optional",+        "sheet": "int, default 1"+      },+      "longRunning": false,+      "name": "fusion_sch_update_from_library",+      "output": {+        "error": "str",+        "errorCode": "unsupported"+      },+      "statusVerb": null,+      "summary": "Refused with unsupported, naming the libraries the design embeds: Fusion updates parts from their libraries in its Library Manager, which asks about each part, so there is no command the bridge can answer up front.",+      "timeoutSeconds": 60     },     {       "example": {-        "name": "TJA1050",-        "projectName": "Main"+        "refs": [+          "U1",+          "C3"+        ]       },       "input": {-        "description": "optional str",-        "folderPath": "optional str",-        "name": "required str",-        "projectName": "optional str"+        "expectDocument": "the design",+        "marginMm": "default 5",+        "outputPath": "the .png (default %TEMP%/adom-sch-zoom/sch_zoom.png)",+        "refs": "[designator] (or ref)",+        "stay": "bool: leave the schematic in front"       },       "longRunning": false,-      "name": "fusion_save_to_cloud",+      "name": "fusion_sch_zoom",       "output": {-        "success": "bool",-        "urn": "str"+        "found": "[ref]",+        "image": "path",+        "missing": "[ref]",+        "rectMm": "[x1, y1, x2, y2]",+        "sheet": "int"       },       "statusVerb": null,-      "summary": "Save the ACTIVE document to Autodesk cloud storage with an explicit name and destination. Dialog-free precisely because you supply what the Save box would ask for - use it before closing or restarting when a document has never been saved (fusion_close_all_documents refuses such a document with unsaved_named_document rather than discarding it).",-      "timeoutSeconds": 180+      "summary": "Find parts on the schematic (the standard's sch_zoom, the schematic half of cross-probing): highlighted with SHOW, the view framed on them round their pins (marginMm), and a picture of that view written as the proof frame (EXPORT IMAGE WINDOW, no foreground). Parts on several sheets: the first sheet holding any of them. The user's tab is put back unless stay:true.",+      "timeoutSeconds": 90     },     {       "example": {@@ -2836,6 +21715,30 @@       "summary": "START HERE for a schematic. ONE verb, three actions. action:\"open\" lands in the schematic editor from whatever names the design: fileName (+projectName) or urn or query for a CLOUD design (opens it, then switches to the schematic view), schPath for a local EAGLE .sch (its sibling .brd is imported with it so parts instantiate, unless withBoard:false; a .sch alone opens dialog-free), or filePath for a Fusion-native .fsch. action:\"create\" writes a blank EAGLE schematic on the box and opens it as a NEW local electronics design with the schematic editor active, no dialog anywhere. action:\"show\" switches the already-open design to its schematic view. Every reply says which underlying verb it used (via). Remember: a schematic is a VIEW of an electronics design, not a file of its own, which is why there is no verb called open_a_schematic_file. To put a library's parts on a NEW schematic and board for showing them off, use fusion_make_showcase_project instead.",       "timeoutSeconds": 240     },+    {+      "example": {+        "designator": "U1",+        "params": true+      },+      "input": {+        "designator": "one part",+        "expectDocument": "the design (default the one in front)",+        "limit": "default 500",+        "paramNamesOnly": "bool",+        "params": "bool",+        "pins": "default true",+        "sheet": "a sheet number, default all"+      },+      "longRunning": false,+      "name": "fusion_schematic_data",+      "output": {+        "components": "[{designator, libReference, comment, gates, pins, params?}]",+        "count": "int"+      },+      "statusVerb": null,+      "summary": "Parts on the schematic (the standard's schematic_data): each with its library part, value, description, gates with position and turn, and pins with pad number, name and electrical type (0 input, 1 io, 2 output, 3 open collector, 4 passive, 5 hi-z, 7 power); params adds its attributes.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {@@ -2855,6 +21758,23 @@       "summary": "Plan a grouped schematic from a netlist: one labelled frame per block, the block's parts in a row, every connected pin given a short stub named for its net and a label. Returns the command groups for fusion_schematic_run (one call per group, so the sheet grows block by block on camera). Pins may be named by pad (U1.3) or pin (U1.VIN). Pure computation from the .lbr; nothing in Fusion changes.",       "timeoutSeconds": 60     },+    {+      "example": {},+      "input": {+        "expectDocument": "the design"+      },+      "longRunning": false,+      "name": "fusion_schematic_review",+      "output": {+        "engine": "str",+        "errors": "[...]",+        "ok": "bool",+        "warnings": "[...]"+      },+      "statusVerb": null,+      "summary": "Review the schematic (the standard's schematic_review), from the shared checks engine: every placed pin with its electrical type (fusion_schematic_data) against the netlist (Fusion keeps board and schematic in step). Errors such as power pins on no net and outputs driving each other; warnings such as inputs left open and single-pin nets.",+      "timeoutSeconds": 150+    },     {       "example": {},       "input": {@@ -2911,6 +21831,29 @@       "summary": "\u26d4 DISABLED (returns an error): the in-app add-in search took 30+ min and CRASHED Fusion (WinError 10054). It is hard-blocked in the bridge. Use fusion_aps_search {query} \u2014 server-indexed, seconds, no Fusion. See the 'fusion-aps-search' skill.",       "timeoutSeconds": 15     },+    {+      "example": {+        "net": "VBUS",+        "zoom": true+      },+      "input": {+        "margin": "mm around the net when zooming, default 1",+        "net": "str (omit to clear)",+        "zoom": "bool, default false"+      },+      "longRunning": false,+      "name": "fusion_select_net",+      "output": {+        "byKind": "{tracks, arcs, vias, pads, pours, other}",+        "net": "str",+        "selected": "int",+        "success": "bool",+        "zoom": "[x0,y0,x1,y1] mm"+      },+      "statusVerb": null,+      "summary": "Highlight one whole net on the live board (every pad, track, via and pour of it) and, with zoom, frame it. No net clears the highlight. Counts what was highlighted by kind.",+      "timeoutSeconds": 60+    },     {       "example": {         "enabled": true@@ -2971,6 +21914,105 @@       "summary": "Read/toggle the 'Adom is driving Fusion' TASKBAR OVERLAY BADGE (STICKY per user, default ON). While the bridge drives Fusion, its Windows taskbar button wears a small Adom mark so the user knows at a glance who is in control; it sheds automatically after 5 minutes of driving-verb idle. No args = read. Turning it off clears any badge immediately.",       "timeoutSeconds": 15     },+    {+      "example": {+        "count": 6,+        "dryRun": true,+        "expectDocument": "BQ25792"+      },+      "input": {+        "count": "2|4|6|8 (required)",+        "dryRun": "bool",+        "expectDocument": "required: the board's name"+      },+      "longRunning": false,+      "name": "fusion_set_layer_count",+      "output": {+        "from": "[layer]",+        "layers": "[F.Cu, In1.Cu, ..., B.Cu]",+        "stackup": "[{type, name, thickness}]",+        "thicknessMm": "number"+      },+      "statusVerb": null,+      "summary": "Set the board's copper layer count to 2, 4, 6 or 8 (the standard's set_layer_count): the board's design rules are saved, given the new layer setup and a regenerated stack-up (copper kept per layer, 0.2 mm prepreg beside the outer layers, cores sharing the rest, so the board thickness is kept), and loaded back. A layer being removed that still carries copper or graphics is refused with the counts. Read back; if the layers are not the ones asked, the board's own rules are loaded back.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "displayed": false,+        "layerId": "B.Cu"+      },+      "input": {+        "designName": "optional str: the board to act on",+        "displayed": "bool, default true",+        "layerId": "required int | str (alias: layer)"+      },+      "longRunning": false,+      "name": "fusion_set_layer_visibility",+      "output": {+        "displayed": "bool",+        "layerId": "int",+        "name": "str",+        "revision": "str",+        "success": "bool"+      },+      "statusVerb": null,+      "summary": "Show or hide one layer of the live 2D board (DISPLAY), read back from the board's own layer flags. Layer by id (fusion_layers), copper name (F.Cu, In1.Cu, B.Cu) or top/bottom. Nothing on the board changes.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "dryRun": true,+        "footprint": "SOT-23-5",+        "libraryPath": "C:/libs/parts.lbr",+        "symbolName": "LDO"+      },+      "input": {+        "dryRun": "bool",+        "footprint": "a footprint in the library (required)",+        "libraryPath": ".lbr on the Fusion machine (required)",+        "symbolName": "the component (required)"+      },+      "longRunning": false,+      "name": "fusion_set_models",+      "output": {+        "component": "str",+        "footprint": "str",+        "removed": "int"+      },+      "statusVerb": null,+      "summary": "The component keeps ONE footprint (the standard's set_models): every other device of the EAGLE component is removed and the footprint's device joins each pin to its pads by number (a repeated number's N@2 pads too). Offline on a .lbr, preflighted; the attributes stay on the kept device.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "outline": {+          "cornerRadius": 2,+          "rect": [+            0,+            0,+            50,+            30+          ]+        }+      },+      "input": {+        "expectedRevision": "str",+        "outline": "{rect:[x0,y0,w,h], cornerRadius?} | {points:[[x,y]...]}"+      },+      "longRunning": false,+      "name": "fusion_set_outline",+      "output": {+        "outlineEdges": "[edge]",+        "replaced": "int",+        "revision": "str",+        "success": "bool",+        "vertices": "int"+      },+      "statusVerb": null,+      "summary": "Replace the board outline (Fusion's Dimension layer 20, its board edge in the CAM output) with a rectangle, rounded corners optional, or a polygon (mm). The old outline lines are deleted, the new ones drawn, and the closed outline read back; if any copper moved, every command is undone.",+      "timeoutSeconds": 180+    },     {       "example": {         "expression": "1.6 mm",@@ -2993,6 +22035,34 @@       "summary": "Set one parameter's expression by name in the ACTIVE 3D Design document (user parameters first, then model parameters). MUTATES the design: the model regenerates and the result carries the post-op dialog array. Requires a Design document to be active (a 2D board or library editor refuses). Read names and current expressions with fusion_get_parameters; units must match the parameter (\"10 mm\", \"5 deg\").",       "timeoutSeconds": 30     },+    {+      "example": {+        "footprint": "SOIC-8",+        "libraryPath": "C:/libs/new.lbr",+        "params": {+          "MPN": "LM358DR"+        },+        "symbolName": "LM358"+      },+      "input": {+        "comment": "str",+        "dryRun": "bool",+        "footprint": "a package in the same library",+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "params": "{MPN: ..., Manufacturer: ...}",+        "symbolName": "default the first component"+      },+      "longRunning": false,+      "name": "fusion_set_params",+      "output": {+        "component": "str",+        "footprint": "str|null",+        "paramsSet": "int"+      },+      "statusVerb": null,+      "summary": "Set attributes on a component of a .lbr (the standard's set_params): params as {key: value} or 'Key=Value;...' on every device, a COMMENT, and with footprint a device on that package whose pins join the pads with the same numbers.",+      "timeoutSeconds": 30+    },     {       "example": {         "theme": "dark"@@ -3009,27 +22079,82 @@       "longRunning": true,       "name": "fusion_set_preference",       "output": {-        "applied": "obj",-        "current": "obj"+        "applied": "obj",+        "current": "obj"+      },+      "statusVerb": null,+      "summary": "Set Fusion appearance/navigation preferences in the LIVE session - applies immediately, NO restart. Keys: theme (light/darkblue/darkgray/classic/device/dark; some builds only ship LightGray/DarkBlue/Device, failures reported per-key), invertScrollZoom (bool - mouse scroll/zoom direction), orbitScheme (fusion360/alias/inventor/solidworks/tinkercad/powermill), modelingOrientation (yup/zup), gestureNav (bool), cameraPivot (bool), lengthUnit (mm/cm/m/in/ft - active design). Per-key outcome in `applied`, resulting state in `current`.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "enabled": "optional bool (omit to read)"+      },+      "longRunning": false,+      "name": "fusion_set_seat_takeover",+      "output": {+        "autoTakeOverSeat": "bool",+        "success": "bool"+      },+      "statusVerb": "fusion_readiness",+      "summary": "Read/toggle the mid-session Autodesk seat-takeover sweep (STICKY per user, default ON). When Autodesk pops 'Active Sessions Exceeded' mid-session, the bridge clicks Continue through BOTH dialogs in the background: this machine takes the seat, the other machine's Fusion suspends RESUMABLY, the user gets one toast. No args = read current value. Gates only the passive sweep - a verb-driven fusion_start still grabs the seat (the user asked for Fusion, so the seat is implied).",+      "timeoutSeconds": 15+    },+    {+      "example": {+        "nets": [+          "VBUS"+        ],+        "widthMm": 0.5+      },+      "input": {+        "designName": "optional str",+        "layer": "optional layer id or name",+        "netClass": "str",+        "nets": "[str]",+        "widthMm": "required float"+      },+      "longRunning": false,+      "name": "fusion_set_track_width",+      "output": {+        "byNet": "{net: count}",+        "changed": "int",+        "notOnBoard": "[str]",+        "revision": "str",+        "success": "bool",+        "widthMm": "float"       },       "statusVerb": null,-      "summary": "Set Fusion appearance/navigation preferences in the LIVE session - applies immediately, NO restart. Keys: theme (light/darkblue/darkgray/classic/device/dark; some builds only ship LightGray/DarkBlue/Device, failures reported per-key), invertScrollZoom (bool - mouse scroll/zoom direction), orbitScheme (fusion360/alias/inventor/solidworks/tinkercad/powermill), modelingOrientation (yup/zup), gestureNav (bool), cameraPivot (bool), lengthUnit (mm/cm/m/in/ft - active design). Per-key outcome in `applied`, resulting state in `current`.",-      "timeoutSeconds": 30+      "summary": "Change the width of the existing tracks on the given nets or net class, optionally one copper layer. Each track is picked with only its layer displayed (the display is restored), then the copper is read back: only the asked tracks may change, and only their width, or every change is undone. Arcs are left alone.",+      "timeoutSeconds": 180     },     {-      "example": {},+      "example": {+        "dryRun": true,+        "libraryPath": "C:/libs/parts.lbr",+        "parameter": "MPN",+        "symbolName": "LDO",+        "visible": true+      },       "input": {-        "enabled": "optional bool (omit to read)"+        "dryRun": "bool",+        "libraryPath": ".lbr on the Fusion machine (required)",+        "parameter": "the attribute, e.g. MPN (required)",+        "symbolName": "the component (required)",+        "visible": "bool, default true"       },       "longRunning": false,-      "name": "fusion_set_seat_takeover",+      "name": "fusion_set_visibility",       "output": {-        "autoTakeOverSeat": "bool",-        "success": "bool"+        "component": "str",+        "parameter": "str",+        "symbolsChanged": "[str]",+        "visible": "bool"       },-      "statusVerb": "fusion_readiness",-      "summary": "Read/toggle the mid-session Autodesk seat-takeover sweep (STICKY per user, default ON). When Autodesk pops 'Active Sessions Exceeded' mid-session, the bridge clicks Continue through BOTH dialogs in the background: this machine takes the seat, the other machine's Fusion suspends RESUMABLY, the user gets one toast. No args = read current value. Gates only the passive sweep - a verb-driven fusion_start still grabs the seat (the user asked for Fusion, so the seat is implied).",-      "timeoutSeconds": 15+      "statusVerb": null,+      "summary": "Show or hide one parameter of a component on the sheet (the standard's set_visibility), offline in a .lbr: EAGLE shows a parameter when the symbol carries a >NAME text for it, so showing adds that text (Info layer, below the body) to each symbol the component draws and hiding removes it. Placed parts follow when the library is updated in the design. Preflighted before writing.",+      "timeoutSeconds": 30     },     {       "example": {},@@ -3046,6 +22171,32 @@       "summary": "Read/toggle auto-sizing Fusion's WINDOW after launch (STICKY, default ON). Fusion opens at whatever geometry it last had, which after an automated launch is often a small default; the bridge grows it to ~92% of the monitor work area, centered, using SetWindowPos with NOACTIVATE (never ShowWindow/maximize) so focus is never stolen. A window the user maximized, or already sized to >=60% of the work area, is left alone. No args = read.",       "timeoutSeconds": 15     },+    {+      "example": {+        "designators": [+          "R1"+        ],+        "dryRun": true,+        "params": {+          "MPN": "0603WAF1002T5E"+        }+      },+      "input": {+        "designators": "['R1','R2'] or 'R1,R2' (required)",+        "dryRun": "bool",+        "expectDocument": "the design",+        "params": "{MPN: ...} or 'Key=Value;...' (required)"+      },+      "longRunning": false,+      "name": "fusion_sheet_params",+      "output": {+        "notFound": "[ref]",+        "updated": "[ref]"+      },+      "statusVerb": null,+      "summary": "Write attributes onto placed parts (the standard's sheet_params, the BOM write-back): MPN, Manufacturer, distributor numbers. Fusion keeps the board's parts in step. Read back; a mismatch undoes the edit.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {@@ -3077,6 +22228,21 @@       "summary": "Switch the OPEN electronics design to its 3D PCB view (populated board). A VIEW of the project, not a standalone file. Orbit it for demos via fusion_run_modeling_script (app.activeViewport.camera + vp.refresh()).",       "timeoutSeconds": 70     },+    {+      "example": {},+      "input": {+        "...": "as fusion_show_3d_package"+      },+      "longRunning": false,+      "name": "fusion_show_3d_chip",+      "output": {+        "...": "as fusion_show_3d_package",+        "aliasOf": "fusion_show_3d_package"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_show_3d_package: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },     {       "example": {         "name": "MYCHIP",@@ -3283,6 +22449,139 @@       "summary": "Submit Autodesk's emailed 6-DIGIT verification code to finish a Fusion sign-in, typed IN THE BACKGROUND (UIA SetValue + Invoke - never steals the user's foreground or moves their cursor). Exists so you can finish a login END TO END for the user instead of parking them on a 2FA screen: if `adom-google` is available in your container, read the code out of their Gmail (`adom-google gmail search 'from:autodesk verification code' --limit 1`), pull the 6 digits, and call this. If adom-google is NOT installed, tell the user that installing it would let you automate logins like this, then let them type it. NEVER ask the user for a code you could read yourself. The bridge ALSO toasts the user's desktop whenever it hits a human wall, so you do not need to ask it to.",       "timeoutSeconds": 90     },+    {+      "example": {},+      "input": {+        "...": "as fusion_account"+      },+      "longRunning": false,+      "name": "fusion_signin_status",+      "output": {+        "...": "as fusion_account",+        "aliasOf": "fusion_account"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_account: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {+        "dryRun": true,+        "size": 1.0+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "required: the board's name",+        "gap": "mm beside the part, default 0.2",+        "minSize": "smallest size to fall back to",+        "padClearance": "default 0.15",+        "refs": "[ref] (default all)",+        "size": "text height mm, default 1.0"+      },+      "longRunning": false,+      "name": "fusion_silk_designators",+      "output": {+        "applied": "int",+        "engine": "str",+        "failed": "int",+        "onPadsBefore": "[ref]",+        "planned": "[{ref, x, y, size, rotation}]",+        "revision": "str",+        "unplaced": "[{ref, why}]"+      },+      "statusVerb": null,+      "summary": "Place every reference designator the way assembly houses want (the standard's silk_designators), planned by the shared checks engine: one size, upright (or turned 90 beside the part), beside its own part, clear of every pad (padClearance, JLCPCB 0.15 mm), other bodies and the other designators, inside the board. Landed with fusion_apply_silkscreen (read back, undone on a mismatch) unless dryRun; parts with no clear spot are listed, not forced.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name"+      },+      "longRunning": false,+      "name": "fusion_silk_state",+      "output": {+        "components": "[{ref,pattern,x,y,rotation,side,body,name:{text,x,y,size,rotation,side,shown},comment:{...},smashed}]",+        "lines": "[{side,x1,y1,x2,y2,width}]",+        "texts": "[{text,x,y,size,rotation,side,layer}]"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "The silkscreen as it stands: every part's body box, its designator and value texts (position, size, rotation, side, shown; a smashed part's own text, else the footprint's placeholder), and the board's free silkscreen lines and texts.",+      "timeoutSeconds": 60+    },+    {+      "example": {+        "dryRun": true+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "required",+        "moveText": "bool, default true"+      },+      "longRunning": false,+      "name": "fusion_silkscreen_prep",+      "output": {+        "after": "{designatorsOnPads}",+        "before": "{designatorsOnPads}",+        "moved": "int",+        "silkOffCopper": "bool (designators)",+        "silkOutsideBoard": "[{kind, x, y}]",+        "stillOnPads": "[{ref, pad}]",+        "unplaced": "int"+      },+      "statusVerb": null,+      "summary": "Get the silkscreen off the copper (the standard's silkscreen_prep, in Fusion's terms): designators on pads are moved off them where they fit (the shared engine's silk_designators plan, applied and read back), counted before and after; loose silk outside the board is listed. A footprint's own silk lines are its library package's in EAGLE, so they cannot be clipped on one board: the fab's CAM clips silkscreen at mask openings (JLCPCB does). dryRun counts and plans only.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "analysis": {+          "points": 20,+          "start": 10,+          "stop": 1000000,+          "sweep": "dec",+          "type": "ac"+        },+        "probes": [+          {+            "net": "OUT"+          }+        ]+      },+      "input": {+        "analysis": "{type: op} | {type: dc, source, start, stop, step} | {type: ac, sweep: dec|oct|lin, points, start, stop} | {type: tran, step, stop, start?} | {type: noise, source, output, reference?, sweep, points, start, stop} | {type: raw, text}",+        "expectDocument": "the design",+        "maxProbes": "default 32",+        "maxRuns": "default 50",+        "monteCarlo": "{runs, distribution: uniform|gaussian, seed, tolerances: {resistor, capacitor, inductor} %}: every R/C/L with a plain value drawn, a signal per run with the drawn values as step",+        "netlistPath": "a .net/.cir on the Fusion machine instead of the design",+        "points": "per signal, default 200 (a ceiling: first, last and extrema kept)",+        "probes": "[{net} | {current: source}]",+        "sweep": "{parameter: R4 | Q1.BF, start, stop, step, scale?: lin|dec|oct}",+        "temperatures": "{start, stop, step} degC",+        "timeoutSec": "default 120"+      },+      "longRunning": false,+      "name": "fusion_simulate",+      "output": {+        "analysis": "str",+        "available": "[net]",+        "engine": "str",+        "missing": "[probe]",+        "netlist": "path",+        "notSimulated": "[ref]",+        "rows": "int",+        "runs": "int",+        "signals": "[{signal, x, y, xUnit, yUnit, phase?, step?}]",+        "totals": "noise: {onoise, inoise} V (a list with step when there are several runs)"+      },+      "statusVerb": null,+      "summary": "Simulate the design (the standard's simulate) with the ngspice Fusion bundles (the engine Fusion's SIM runs), without Fusion's simulation dialog: the design's SPICE netlist (fusion_export_spice) gets the analysis and a .control block, and ngspice runs it in batch mode in a child process. analysis op, dc, ac (dec, oct, lin), tran or raw SPICE text; probes by net or source current (default every net, up to maxProbes); signals come back as x/y data, AC as dB with the unwrapped phase in degrees. sweep steps a part's value (R4) or a model parameter (Q1.BF) and temperatures the temperature, one run each (ngspice alter/altermod/option temp in one batch), each run its own signal with step (\"R4 = 300, T = 85\"). A partly modelled sheet runs and names the parts it left out in notSimulated; one with no modelled part refuses with no_model. netlistPath simulates a netlist file instead.",+      "timeoutSeconds": 300+    },     {       "example": {},       "input": {@@ -3327,17 +22626,84 @@     {       "example": {},       "input": {+        "...": "as fusion_readiness"+      },+      "longRunning": false,+      "name": "fusion_status",+      "output": {+        "...": "as fusion_readiness",+        "aliasOf": "fusion_readiness"+      },+      "statusVerb": null,+      "summary": "The EDA Bridge Standard's name for fusion_readiness: the same verb, same arguments and reply (marked aliasOf). One name across Altium, KiCad and Fusion bridges.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "closeTimeoutSec": "optional number, default 120: how long to wait for Fusion's windows to close",         "skipCleanClose": "optional bool"       },       "longRunning": false,       "name": "fusion_stop",       "output": {         "output": "str",-        "success": "bool"+        "success": "bool",+        "unsavedWork": "[{window, prompt}] when unsaved work stopped it"       },       "statusVerb": null,-      "summary": "Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait. NO force-kill - the clean opposite of fusion_start. If a window will not close it returns failure; use fusion_kill then.",-      "timeoutSeconds": 60+      "summary": "Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait up to closeTimeoutSec (default 120; heavy designs take minutes to close). NO force-kill - the clean opposite of fusion_start. A save prompt for a document the bridge made is answered Don't Save; one for anyone else's unsaved work is cancelled and the stop fails with errorCode unsaved_work (nothing saved or lost). If a window will not close it returns failure; use fusion_kill then.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "assigns": "1=GND;2=VDD",+        "footprintName": "VL53L5CX",+        "libraryPath": "C:/libs/sensors.lbr",+        "pcbPath": "C:/Boards/tof-test.brd"+      },+      "input": {+        "assigns": "pad=NET;...",+        "designator": "the part (default: the first)",+        "footprintName": "str (required)",+        "libraryPath": ".lbr holding the footprint (required)",+        "open": "bool, default true",+        "pcbPath": ".brd (required)"+      },+      "longRunning": false,+      "name": "fusion_swap_footprint",+      "output": {+        "data": "{placed, padsOnComp, bodiesOnComp}",+        "documentName": "str",+        "swap": "{designator, from, to, padsWired, unknownPads, has3d}"+      },+      "statusVerb": null,+      "summary": "A part on a board kept as EAGLE source (fusion_test_board's .brd) takes another footprint from a .lbr at the same place and turn (the standard's swap_footprint); its pads leave their nets and take assigns (pad number -> net, every pad of that number); tracks stay. designator picks the part (default: the first). The board reopens in Fusion as a local design and is read back.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "libraryPath": "C:/libs/parts.lbr",+        "symbolName": "LDO"+      },+      "input": {+        "libraryPath": ".lbr on the Fusion machine (required)",+        "symbolName": "the component (required)"+      },+      "longRunning": false,+      "name": "fusion_symbol_prims",+      "output": {+        "bodyRectMil": "[x1, y1, x2, y2]",+        "lines": "int",+        "models": "[{type, name, device}]",+        "pins": "int",+        "polyBboxMil": "[x1, y1, x2, y2] | null",+        "polylines": "int",+        "rectangles": "int"+      },+      "statusVerb": null,+      "summary": "A component's drawing (the standard's symbol_prims), offline from a .lbr: primitive counts by kind (pins, lines, rectangles, polygons, circles, arcs, texts) over the symbols its gates draw, the body rectangle and the polygons' box in mil, and its footprints (the component's devices). Read-only: verifies import_part, set_models and add_models.",+      "timeoutSeconds": 30     },     {       "example": {},@@ -3355,6 +22721,96 @@       "summary": "Screenshot the Fusion window in the BACKGROUND (no focus steal, reads through occlusion). Use it to VERIFY your own work: geometry at the wrong Z, an empty view, or a Placeholder 3D body all render successfully and only a look at the pixels catches them.",       "timeoutSeconds": 60     },+    {+      "example": {+        "dryRun": true,+        "targets": [+          "via"+        ]+      },+      "input": {+        "dryRun": "bool",+        "expectDocument": "required",+        "lengthRatio": "default 0.5",+        "targets": "[via, tht, smd] (default all)",+        "widthRatio": "default 1.0"+      },+      "longRunning": false,+      "name": "fusion_teardrops",+      "output": {+        "applied": "int",+        "engine": "str",+        "skipped": "[{at, why}]",+        "teardrops": "[{at, net, layer, points}]"+      },+      "statusVerb": null,+      "summary": "Teardrops where tracks meet vias and pads (the standard's teardrops), planned by the shared checks engine to hold the board's clearance: each a filled polygon on the track's layer and net; the ones that would not fit are skipped with why. Fusion draws them as named solid polygons (rank 1, no thermals), reads them back and undoes all on a mismatch; dryRun returns the plan.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "footprintName": "VL53L5CX;VL53L7CX",+        "libraryPath": "C:/libs/sensors.lbr",+        "pcbPath": "C:/Boards/tof-test.brd"+      },+      "input": {+        "assigns": "pad=NET;... (last part)",+        "footprintName": "str | 'A;B;C' (required)",+        "hMm": "number (new board only)",+        "layers": "2|4|6|8 (new board)",+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "open": "bool, default true",+        "pcbPath": "a .brd: existing = append, new = create (default %TEMP%/adom-test-boards/<name>.brd)",+        "prefix": "designator prefix, default U",+        "stubs": "pad=x,y;... mm from the part's origin (last part): a 0.2 mm top track",+        "wMm": "number (new board only)"+      },+      "longRunning": false,+      "name": "fusion_test_board",+      "output": {+        "appended": "bool",+        "bodiesOnComp": "int",+        "count": "int (parts on the board)",+        "documentName": "str",+        "existingParts": "int",+        "padsOnComp": "int",+        "pcb": "path",+        "placed": "'U1;U2'",+        "saved": "bool (checked on disk)",+        "unknownPins": "[]"+      },+      "statusVerb": null,+      "summary": "Footprints from a .lbr on ONE board (the standard's test_board): a NEW board (wMm x hMm outline, or one that fits the row) when pcbPath is new or omitted, APPENDED right of the current parts when pcbPath is an existing .brd, designators continuing (U4...). Written as EAGLE source, opened in Fusion as a local design dialog-free, and read back. assigns and stubs apply to the LAST part placed.",+      "timeoutSeconds": 180+    },+    {+      "example": {+        "dryRun": true,+        "ref": "U3"+      },+      "input": {+        "drill": "mm",+        "dryRun": "bool",+        "expectDocument": "required",+        "insetMm": "default 0.1",+        "pad": "default its largest pad",+        "pitchMm": "default size + 0.5, at least 1",+        "ref": "the part (required)",+        "size": "via diameter mm"+      },+      "longRunning": false,+      "name": "fusion_thermal_vias",+      "output": {+        "applied": "int",+        "apply": "dryRun: {verb: fusion_place_vias, args: {vias}}",+        "engine": "str",+        "failed": "int",+        "planned": "{part, pad, net, padMm, vias, pitchMm, via: {sizeMm, drillMm, from}, points}"+      },+      "statusVerb": null,+      "summary": "A thermal via grid in a part's exposed pad (the standard's thermal_vias), planned by the shared checks engine: centred, inset from the pad's edge, clear of vias already there, sized by size/drill or the board's via rule, on the pad's net. Fusion places it, reads it back and undoes it on a mismatch; dryRun returns the plan with apply as fusion_place_vias arguments.",+      "timeoutSeconds": 180+    },     {       "example": {         "dryRun": true@@ -3378,6 +22834,76 @@       "summary": "CASCADE CLEANUP, called by ab's bridge_uninstall BEFORE this bridge's cache is deleted (ab 2.0.35+). Removes the artifacts this bridge planted OUTSIDE its cache: the Fusion ADD-IN in Autodesk's AddIns directories (all three historical locations), plus this bridge's prefs (~/.adom/fusion-bridge) and APS OAuth tokens (~/.adom/fusion-aps). This matters more here than for most bridges: a stale AdomBridge add-in keeps loading on every Fusion launch and binding its port long after the bridge is gone. Fusion itself is never touched. Pass dryRun:true to see exactly what would be removed. If Fusion is RUNNING it holds the add-in files open, so removal may fail - the response says so and names the remedy.",       "timeoutSeconds": 60     },+    {+      "example": {+        "brdPath": "C:/work/board.brd",+        "expectDocument": "Buck12V5V",+        "save": true+      },+      "input": {+        "brdPath": "required: .brd or .fbrd on the Fusion machine",+        "comment": "the version comment",+        "dryRun": "bool: the plan only",+        "expectDocument": "required: the open board's name",+        "expectedRevision": "optional",+        "save": "bool, default false: save in place after a verified read back"+      },+      "longRunning": true,+      "name": "fusion_update_board_from_eagle",+      "output": {+        "mismatched": "[str]",+        "notSynced": "[str]",+        "plan": "{partsMoved, copper, pours, outline, looseCopper, holes}",+        "revision": "str",+        "save": "fusion_save_document's reply",+        "saved": "bool",+        "success": "bool",+        "unconnected": "int",+        "verified": "bool"+      },+      "statusVerb": null,+      "summary": "Make the open design's board the board in an EAGLE .brd (or a .fbrd) on the Fusion machine, in place, so the design keeps its files and gets a new version instead of a new design (page issue #125, item 4): parts moved and turned by name, tracks and vias ripped up and drawn from the file, pours, the outline, holes and net-less copper replaced, then the whole board read back against the file. With save:true it is saved in place, and only after an exact read back. A file whose parts or nets differ (a schematic change) is refused with schematic_differs. Silkscreen and documentation, design rules and name/value positions are not synced; notSynced says when the file differs in them.",+      "timeoutSeconds": 300+    },+    {+      "example": {+        "libraryPath": "C:/libs/parts.lbr"+      },+      "input": {+        "apply": "refused: see above",+        "expectDocument": "the board (required)",+        "libraries": "[.lbr] (instead of libraryPath)",+        "libraryPath": ".lbr to compare against",+        "refs": "[ref] (default every part)"+      },+      "longRunning": false,+      "name": "fusion_update_footprints_from_library",+      "output": {+        "differs": "int",+        "footprints": "[{ref, footprint, library, status, diff?: {padsAdded, padsRemoved, padsChanged: [{pad, changes}]}, why?}]",+        "plan": "true",+        "revision": "str"+      },+      "statusVerb": null,+      "summary": "Compare placed footprints with their library (the standard's update_footprints_from_library), the plan: each part's footprint as the board holds it against the same-named package in the .lbr files named, pad by pad (added, removed, moved, resized, reshaped, drill, turn, layer), each up_to_date, differs or library_not_found. A Fusion design's libraries are cloud items, so the .lbr files are named. apply:true is refused (not_supported) with the plan: Fusion's UPDATE asks about each part in a dialog.",+      "timeoutSeconds": 120+    },+    {+      "example": {},+      "input": {+        "expectDocument": "the design",+        "name": "a variant name: refused (not_supported), see above"+      },+      "longRunning": false,+      "name": "fusion_variants",+      "output": {+        "variant": "the one edited, as read back",+        "variants": "[{name, current, notFitted, alternates}]"+      },+      "statusVerb": null,+      "summary": "Assembly variants of the open design (the standard's variants): the list, each variant with its not-fitted parts and alternate values, read from the schematic. Making, changing or removing one is refused with not_supported: Fusion takes EAGLE's VARIANT from a text command and changes nothing (checked live on Fusion 2706), so those are done in Fusion's schematic editor.",+      "timeoutSeconds": 120+    },     {       "example": {},       "input": {},@@ -3390,6 +22916,42 @@       "summary": "This machine MEASURED timings per verb/stage - the same store that paces every progress bar and ETA. Read it to see whether an estimate is measured (this box has run it) or typical (still the seeded literal), and to explain a slow run.",       "timeoutSeconds": 15     },+    {+      "example": {+        "dryRun": true,+        "freqGHz": 2.4,+        "nets": [+          "ANT"+        ],+        "viaNet": "GND"+      },+      "input": {+        "clearance": "default 0.2",+        "drill": "default 0.3",+        "dryRun": "bool",+        "edge": "bool",+        "edgeInsetMm": "number",+        "expectDocument": "required",+        "freqGHz": "number",+        "nets": "[net]",+        "offsetMm": "track to via centre",+        "pitchMm": "default 2",+        "size": "default 0.6",+        "viaNet": "usually GND (required)"+      },+      "longRunning": false,+      "name": "fusion_via_fence",+      "output": {+        "applied": "int",+        "apply": "dryRun: {verb: fusion_place_vias, args: {vias}}",+        "engine": "str",+        "failed": "int",+        "planned": "{vias, candidates, via, pitchMm, offsetMm, points}"+      },+      "statusVerb": null,+      "summary": "A via fence for EMC (the standard's via_fence), planned by the shared checks engine: vias on viaNet both sides of the nets' tracks and/or round the board edge, at lambda/20 for freqGHz or a pitch; each clear of other copper, pads and the edge. Fusion places them, reads them back and undoes them on a mismatch; dryRun returns the plan.",+      "timeoutSeconds": 180+    },     {       "example": {},       "input": {@@ -3452,6 +23014,47 @@       "statusVerb": "fusion_get_app_state",       "summary": "Sign a pup browser window into an Autodesk WEB surface (library.io, the hub portal at <hub>.autodesk360.com, Autodesk Account) via Google SSO. Fusion's DESKTOP app being signed in does NOT sign these in - they are separate web sessions. NEVER guesses a credential: a missing password or a 2FA challenge comes back as a typed stop (human_credential_required / second_factor_required / google_sso_unavailable) naming the one-time command the USER runs. The password never passes through this bridge or the AI - it is stored once with ab's credential_set and filled by pup in the background.",       "timeoutSeconds": 240+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "fromLib": "source .lbr",+        "to": "default same name",+        "toLib": "destination .lbr (required)"+      },+      "longRunning": false,+      "name": "fusion_xcopy_footprint",+      "output": {+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Copy a footprint from one .lbr into another (the standard's xcopy_footprint), optionally under a new name; the destination is created when missing.",+      "timeoutSeconds": 30+    },+    {+      "example": {+        "expectDocument": "fusion-routing"+      },+      "input": {+        "boardId": "optional",+        "expectDocument": "required exact active board name",+        "margin": "mm, default 1",+        "net": "optional net",+        "rect": "optional [x1,y1,x2,y2] mm",+        "ref": "optional designator",+        "refs": "optional [designator]"+      },+      "longRunning": false,+      "name": "fusion_zoom_to",+      "output": {+        "rect": "[x0,y0,x1,y1] mm framed"+      },+      "statusVerb": "fusion_routing_state",+      "summary": "Frame Fusion's board view on a rectangle, a part (or several) or a whole net, with a margin. Inside Fusion only: no window focus or mouse.",+      "timeoutSeconds": 60     }   ] }