@chestnutlabs/gcode-parser 0.2.0 → 0.4.0

package/dist/growable.d.ts

@@ -28,6 +28,9 @@ export interface SegmentRecord {
     tool: number;
     layer: number;
     srcByte: number;
+    /** Current value of each requested opt-in modal channel (DD-012 D3), keyed by channel id.
+     *  Missing/undefined entries store NaN — an honest "no value here", never a fabricated 0. */
+    modal?: Record<string, number>;
 }
 export interface FinalChannels {
     count: number;
@@ -45,6 +48,9 @@ export interface FinalChannels {
     feature: Uint8Array;
     object: Uint32Array;
     srcByte: Uint32Array;
+    /** Opt-in modal channels (DD-012 D3), present only when requested at construction. Each is a
+     *  Float32 column of length `count`; an unset value is NaN, never a fabricated 0. */
+    modal?: Record<string, Float32Array>;
 }
 export declare class SegmentWriter {
     private readonly maxBufferBytes;
@@ -68,7 +74,13 @@ export declare class SegmentWriter {
     private accountedBytes;
     /** Extra live bytes the caller wants included in the budget (line buffer, warnings). */
     private externalBytes;
-    constructor(maxBufferBytes: number);
+    /** Opt-in modal channel ids (DD-012 D3), stable order; empty for a default parse. */
+    private readonly modalNames;
+    /** Growable Float32 columns, parallel to `modalNames`. */
+    private modalArrays;
+    /** Bytes per segment across the core set plus any requested modal columns. */
+    private readonly bytesPerSegment;
+    constructor(maxBufferBytes: number, modalChannels?: readonly string[]);
     get count(): number;
     get accounted(): number;
     /** Report additional live working bytes (e.g., the line-drain buffer) into the budget. */
@@ -82,6 +94,9 @@ export declare class SegmentWriter {
     setLayerRange(start: number, end: number, layerIndex: number): void;
     /** Zero the whole layer channel (non-planar clearing semantics). */
     clearLayers(): void;
+    /** Build the optional `modal` output record (DD-012 D3), or `{}` when no channels were requested
+     *  so a default parse yields no `modal` key at all. `view` slices/subarrays each column to count. */
+    private modalOutput;
     /**
      * Copy a segment range into fresh right-sized arrays (progressive-preview
      * snapshots, DD-004 §5.4 / issue #60). Budget-checked: the copies coexist with

package/dist/growable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"growable.d.ts","sourceRoot":"","sources":["../src/growable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qBAAa,mBAAoB,SAAQ,KAAK;aAE1B,cAAc,EAAE,MAAM;aACtB,cAAc,EAAE,MAAM;aACtB,cAAc,EAAE,MAAM;gBAFtB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM;CAOzC;AAuBD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,YAAY,CAAC;IACjB,CAAC,EAAE,YAAY,CAAC;IAChB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,WAAW,CAAC;CACtB;AAID,qBAAa,aAAa;IAwBZ,OAAO,CAAC,QAAQ,CAAC,cAAc;IAvB3C,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,CAAC,CAAgB;IACzB,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAe;IAE9B,wEAAwE;IACxE,OAAO,CAAC,cAAc,CAAK;IAC3B,wFAAwF;IACxF,OAAO,CAAC,aAAa,CAAK;gBAEG,cAAc,EAAE,MAAM;IAInD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,0FAA0F;IAC1F,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIrC,mFAAmF;IACnF,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,QAAQ;IAwDhB,yFAAyF;IACzF,IAAI,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI;IAsB5B,4FAA4F;IAC5F,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAInE,oEAAoE;IACpE,WAAW,IAAI,IAAI;IAInB;;;;;;OAMG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa;IAsBxD,qFAAqF;IACrF,QAAQ,IAAI,aAAa;CAsB1B"}
+{"version":3,"file":"growable.d.ts","sourceRoot":"","sources":["../src/growable.ts"],"names":[],"mappings":"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"}

package/dist/growable.js

@@ -37,7 +37,8 @@ const CHANNELS = [
     { name: 'object', bytesPerElement: 4 },
     { name: 'srcByte', bytesPerElement: 4 }
 ];
-const BYTES_PER_SEGMENT = CHANNELS.reduce((a, c) => a + c.bytesPerElement, 0); // 40 B core set
+const CORE_BYTES_PER_SEGMENT = CHANNELS.reduce((a, c) => a + c.bytesPerElement, 0); // 40 B core set
+const MODAL_BYTES_PER_ELEMENT = 4; // each opt-in modal channel is one Float32 column
 const INITIAL_CAPACITY = 4096;
 export class SegmentWriter {
     maxBufferBytes;
@@ -61,8 +62,16 @@ export class SegmentWriter {
     accountedBytes = 0;
     /** Extra live bytes the caller wants included in the budget (line buffer, warnings). */
     externalBytes = 0;
-    constructor(maxBufferBytes) {
+    /** Opt-in modal channel ids (DD-012 D3), stable order; empty for a default parse. */
+    modalNames;
+    /** Growable Float32 columns, parallel to `modalNames`. */
+    modalArrays = [];
+    /** Bytes per segment across the core set plus any requested modal columns. */
+    bytesPerSegment;
+    constructor(maxBufferBytes, modalChannels = []) {
         this.maxBufferBytes = maxBufferBytes;
+        this.modalNames = modalChannels;
+        this.bytesPerSegment = CORE_BYTES_PER_SEGMENT + MODAL_BYTES_PER_ELEMENT * modalChannels.length;
         this.allocate(INITIAL_CAPACITY);
     }
     get count() {
@@ -83,7 +92,7 @@ export class SegmentWriter {
     }
     allocate(newCapacity) {
         // During a grow/compact, old and new capacity coexist until copies complete.
-        const newBytes = newCapacity * BYTES_PER_SEGMENT;
+        const newBytes = newCapacity * this.bytesPerSegment;
         this.ensureBudget(newBytes);
         const nx0 = new Float32Array(newCapacity);
         const ny0 = new Float32Array(newCapacity);
@@ -99,6 +108,13 @@ export class SegmentWriter {
         const nfeature = new Uint8Array(newCapacity);
         const nobject = new Uint32Array(newCapacity);
         const nsrc = new Uint32Array(newCapacity);
+        // Opt-in modal columns grow in lockstep with the core set.
+        const nmodal = this.modalNames.map((_, k) => {
+            const a = new Float32Array(newCapacity);
+            if (this.capacity > 0)
+                a.set(this.modalArrays[k].subarray(0, this._count));
+            return a;
+        });
         if (this.capacity > 0) {
             nx0.set(this.x0.subarray(0, this._count));
             ny0.set(this.y0.subarray(0, this._count));
@@ -115,7 +131,8 @@ export class SegmentWriter {
             nobject.set(this.object.subarray(0, this._count));
             nsrc.set(this.srcByte.subarray(0, this._count));
         }
-        const oldBytes = this.capacity * BYTES_PER_SEGMENT;
+        const oldBytes = this.capacity * this.bytesPerSegment;
+        this.modalArrays = nmodal;
         this.x0 = nx0;
         this.y0 = ny0;
         this.z0 = nz0;
@@ -153,6 +170,10 @@ export class SegmentWriter {
         this.feature[i] = 0;
         this.object[i] = 0;
         this.srcByte[i] = s.srcByte;
+        for (let k = 0; k < this.modalNames.length; k++) {
+            const v = s.modal?.[this.modalNames[k]];
+            this.modalArrays[k][i] = v === undefined ? NaN : v;
+        }
         this._count++;
     }
     /** Overwrite the layer channel for a segment range (used for post-hoc layer resolution). */
@@ -163,6 +184,16 @@ export class SegmentWriter {
     clearLayers() {
         this.layer.fill(0, 0, this._count);
     }
+    /** Build the optional `modal` output record (DD-012 D3), or `{}` when no channels were requested
+     *  so a default parse yields no `modal` key at all. `view` slices/subarrays each column to count. */
+    modalOutput(view) {
+        if (this.modalNames.length === 0)
+            return {};
+        const modal = {};
+        for (let k = 0; k < this.modalNames.length; k++)
+            modal[this.modalNames[k]] = view(this.modalArrays[k]);
+        return { modal };
+    }
     /**
      * Copy a segment range into fresh right-sized arrays (progressive-preview
      * snapshots, DD-004 §5.4 / issue #60). Budget-checked: the copies coexist with
@@ -172,9 +203,10 @@ export class SegmentWriter {
      */
     snapshotRange(start, end) {
         const count = Math.max(0, end - start);
-        this.ensureBudget(count * BYTES_PER_SEGMENT);
+        this.ensureBudget(count * this.bytesPerSegment);
         return {
             count,
+            ...this.modalOutput((a) => a.slice(start, end)),
             x0: this.x0.slice(start, end),
             y0: this.y0.slice(start, end),
             z0: this.z0.slice(start, end),
@@ -198,6 +230,7 @@ export class SegmentWriter {
         }
         return {
             count: this._count,
+            ...this.modalOutput((a) => a.subarray(0, this._count)),
             x0: this.x0.subarray(0, this._count),
             y0: this.y0.subarray(0, this._count),
             z0: this.z0.subarray(0, this._count),

package/dist/parse.d.ts

@@ -56,6 +56,21 @@ export interface ParseOptions {
     limits?: Partial<ParseLimits>;
     /** Layer-detection tolerance (inherited default 0.05). */
     minLayerThreshold?: number;
+    /**
+     * Firmware hint (DD-010 D2): does `G90`/`G91` also set the *extruder* mode? Marlin/Klipper —
+     * `true`; RepRapFirmware treats E independently — `false`. Default `false` (RRF/unknown-conservative).
+     * Only consulted while no `M82`/`M83` has latched the E-mode; supplied by the dialect layer / caller
+     * that has confidently classified the firmware. The byte-exact engine never sniffs firmware itself.
+     */
+    extruderFollowsPositioning?: boolean;
+    /**
+     * Opt-in modal channels to capture per segment (DD-012 D3, #189). Each requested id adds one
+     * Float32 column to the IR (`segments.modal[id]`); a default parse requests none and pays nothing,
+     * so FDM output is unchanged. Supported id: `'toolPower'` — the modal spindle/laser `S` value while
+     * a tool is engaged (`M3`/`M4`), NaN when the tool is off. Presentation (Watts vs RPM) is a dialect
+     * label, not a separate channel (DD-012 D4). Fan/temp/accel etc. (#180) reuse the same mechanism.
+     */
+    modalChannels?: readonly string[];
     /**
      * DD-005 §4.3 read-only hooks: observe comments/commands during the parse.
      * Inert when unset (one branch per line); they cannot alter lexing, dispatch,

package/dist/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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"}

package/dist/parse.js

@@ -38,29 +38,61 @@ export const DEFAULT_LIMITS = {
 };
 const LAYER_TOLERANCE = 0.05;
 const UNRESOLVED_LAYER = 0xffffffff;
+/** Opt-in modal channels this engine can capture (DD-012 D3, #189). Requested via
+ *  `ParseOptions.modalChannels`; unknown ids are ignored with a warning. Extend as later phases
+ *  (spindle/laser already covered by `toolPower`; #180's fan/temp/accel land here next). */
+const SUPPORTED_MODAL_CHANNELS = new Set(['toolPower']);
 const SPLIT_LETTERS = /([a-zA-Z])/g;
-/** Port of the inherited lexer: trim, comment split on ';', letter/value pairs. */
+/**
+ * Lex a line into its G/M/T command words plus the axis/param words. Real CNC G-code routinely puts
+ * several commands on one line and prefixes lines with `N` line numbers; both are handled here.
+ * `N`-words (line numbers) are dropped, and non-command letters become params. FDM lines have a single
+ * command word, so `codes = [thatCommand]` and behavior is byte-identical to the inherited lexer.
+ */
 function lexLine(line) {
-    const input = line.trim();
-    const cmd = input.split(';')[0];
-    const parts = cmd
+    const body = line.trim().split(';')[0];
+    const parts = body
         .split(SPLIT_LETTERS)
         .slice(1)
         .map((s) => s.trim());
-    const gcode = !parts.length ? '' : `${parts[0]?.toLowerCase()}${Number(parts[1])}`;
-    // Faithful replication of the inherited parseParams reduce (odd indices are values):
+    const codes = [];
     const params = {};
-    const rest = parts.slice(2);
-    for (let idx = 0; idx < rest.length; idx++) {
-        if (idx % 2 === 0)
-            continue;
-        const key = rest[idx - 1].toLowerCase();
-        const code = key.charCodeAt(0);
-        if ((code >= 97 && code <= 122) || (code >= 65 && code <= 90)) {
-            params[key] = parseFloat(rest[idx]);
+    let sawCommand = false;
+    for (let i = 0; i + 1 < parts.length; i += 2) {
+        const key = parts[i].toLowerCase();
+        const cc = key.charCodeAt(0);
+        if (cc < 97 || cc > 122)
+            continue; // not a letter
+        const value = parts[i + 1];
+        // A real G-code word is a letter followed by a NUMBER. This guard rejects letters embedded in
+        // extended-command words (Klipper `EXCLUDE_OBJECT … POLYGON=…`, `CENTER=`, `NAME=`) where a letter
+        // is followed by another letter or `=…` — the inherited lexer skipped these by only reading the
+        // first word; scanning every letter must not resurrect them as commands/params.
+        const num = value.trim() === '' ? NaN : Number(value);
+        if (key === 'g' || key === 'm') {
+            if (Number.isFinite(num)) {
+                codes.push(`${key}${num}`); // e.g. 'g1', 'm3' — leading zeros normalized
+                sawCommand = true;
+            }
+        }
+        else if (key === 't' && !sawCommand) {
+            // `T` is a tool-select command only as the LEADING command word (`T1 M6`). After an M-code it is
+            // that code's parameter, NOT a tool change — e.g. Marlin `M486 T<count>`, `M104 T<tool> S<temp>`.
+            if (Number.isFinite(num)) {
+                codes.push(`t${num}`);
+                sawCommand = true;
+            }
+        }
+        else if (key === 'n') {
+            // Line number — not a command, not a motion word. Ignored (fixes Fanuc/Mach/TinyG files).
+        }
+        else {
+            const p = parseFloat(value);
+            if (Number.isFinite(p))
+                params[key] = p;
         }
     }
-    return { gcode, params };
+    return { codes, params };
 }
 /** Internal: build an engine over decoded text (streaming passes '' and feeds lines itself). */
 export function createEngine(input, opts) {
@@ -92,7 +124,18 @@ export function createEngine(input, opts) {
             warnings.set(code, { code, message, severity: 'warn', srcByte, count: 1 });
         }
     };
-    const writer = new SegmentWriter(limits.maxBufferBytes);
+    // Opt-in modal channels (DD-012 D3): dedupe, keep supported, warn (once) on any unknown id.
+    const requestedModal = [];
+    for (const id of opts.modalChannels ?? []) {
+        if (!SUPPORTED_MODAL_CHANNELS.has(id)) {
+            warn('modal-channel-unsupported', `Ignoring unsupported modal channel '${id}'.`);
+        }
+        else if (!requestedModal.includes(id)) {
+            requestedModal.push(id);
+        }
+    }
+    const wantToolPower = requestedModal.includes('toolPower');
+    const writer = new SegmentWriter(limits.maxBufferBytes, requestedModal);
     // Machine state (port of State.initial + Interpreter fields).
     let sx = 0;
     let sy = 0;
@@ -101,6 +144,79 @@ export function createEngine(input, opts) {
     let units = 'mm';
     let unitsSeen = false;
     let modalFeed = NaN;
+    // Motion-model modal state (DD-010 E10 phase 1). `xyzAbsolute` (G90/G91) and the extruder mode
+    // resolve the effective per-move E delta and the extrude/travel classification. Defaults are the
+    // firmware power-on convention: absolute XYZ, absolute E. `eModeExplicit` is set only by M82/M83;
+    // `lastE` is the running absolute-E datum (also reset by `G92 E`).
+    let xyzAbsolute = true;
+    let positioningSeen = false; // any G90/G91 observed → positioningMode 'known'
+    let eModeExplicit = null; // M82/M83; null = infer
+    let lastE = 0;
+    const extruderFollowsPositioning = opts.extruderFollowsPositioning === true;
+    // Arc-plane modal state (DD-010 D3, #157, E10 phase 2). G17=XY (default, power-on),
+    // G18=XZ, G19=YZ. Arc flattening runs in the active plane; the through axis ramps linearly.
+    let arcPlane = 'xy';
+    let arcPlaneSeen = false; // any G17/G18/G19 observed → arcPlanes 'known'
+    // Coordinate systems (DD-010 D4, #158, E10 phase 3). The IR stays in the logical/work frame
+    // (Option A): the emitted position is `commanded + activeWcsOffset + g92off`. FDM slicer files use
+    // the identity WCS with no G92, so every offset is 0 → the corpus is byte-identical. G54–G59 select
+    // a per-system offset (settable via G10 L2/L20); G92 X/Y/Z shifts the datum without motion; G53 is a
+    // one-shot machine-coordinate bypass for the following move.
+    let activeWcs = 0; // 0..5 → G54..G59; G54 (identity) is the power-on default
+    const wcsOffsets = Array.from({ length: 6 }, () => ({ x: 0, y: 0, z: 0 }));
+    let g92x = 0;
+    let g92y = 0;
+    let g92z = 0;
+    let coordSystemSeen = false; // any G53/G54–G59/G92-XYZ/G10 → coordinateSystem 'known'
+    let g53OneShot = false; // next move ignores the work offset (machine coordinates)
+    // Tool-state modal (DD-012 D2/D4, #189). Spindle/laser on (M3/M4) engages the tool; M5 disengages.
+    // A FEED move (G1/G2/G3) with no extrusion E while the tool is engaged is a Cut (productive); a
+    // rapid (G0) stays Travel even with the tool engaged (refined #189). FDM slices never issue M3/M4,
+    // so toolEngaged stays false and their classification is byte-identical.
+    let toolEngaged = false;
+    let toolStateSeen = false; // any M3/M4/M5 observed → cutMoves capability 'known'
+    let modalS = NaN; // current modal spindle/laser S value (power / RPM); NaN until first seen (#189)
+    let modalMotion = null; // last G0–G3 mode for modal-motion lines (#189)
+    // Canned drilling cycle state (DD-012 phase 2, #189). Z/R/Q/initial-plane are captured when the
+    // cycle is defined and retained across modal (bare X/Y) repeats until G80 or a G0–G3 cancels it.
+    let cannedCycle = null;
+    let cannedZ = 0; // final drill depth (absolute)
+    let cannedR = 0; // retract / reference plane (absolute Z)
+    let cannedQ = 0; // peck increment (G83)
+    let cannedInitialZ = 0; // Z when the cycle activated — the G98 retract plane
+    let cannedRetractInitial = true; // G98 (retract to initial Z) vs G99 (retract to R); modal, default G98
+    let cannedCyclesSeen = false; // any G81/G82/G83 expanded → cannedCycles capability 'known'
+    // Per-axis position certainty (DD-010 D4 amendment, #158). A G31 probe endpoint is reached at
+    // RUNTIME (workpiece contact), not the commanded value, so it marks the probed axes uncertain. A
+    // following G92 then RESYNCS the logical frame at the datum (rather than datum-shifting a stale
+    // position); an absolute move re-establishes certainty. Independent of the work offsets above.
+    let certainX = true;
+    let certainY = true;
+    let certainZ = true;
+    const offX = () => (g53OneShot ? 0 : wcsOffsets[activeWcs].x + g92x);
+    const offY = () => (g53OneShot ? 0 : wcsOffsets[activeWcs].y + g92y);
+    const offZ = () => (g53OneShot ? 0 : wcsOffsets[activeWcs].z + g92z);
+    /**
+     * Effective per-move E delta from the modal extruder mode (DD-010 D1/D2 precedence:
+     * explicit M82/M83 → firmware-conditioned G90/G91 → absolute default). Updates `lastE`.
+     * For relative E the delta is the raw word (byte-identical to the pre-E10 engine for the
+     * M83 corpus); for absolute E it is `eParam − lastE`.
+     */
+    const resolveEDelta = (eParam) => {
+        if (eParam === undefined)
+            return 0;
+        const absolute = eModeExplicit !== null ? eModeExplicit === 'absolute' : extruderFollowsPositioning ? xyzAbsolute : true; // firmware-neutral default: absolute, disclosed 'inferred'
+        const delta = absolute ? eParam - lastE : eParam;
+        lastE = absolute ? eParam : lastE + eParam;
+        return delta;
+    };
+    /**
+     * Logical (work-frame) target for one axis given the positioning mode (G90/G91) and the active
+     * work offset (DD-010 D4). Absolute: `word + off`; relative: `cur + word` (the offset is already
+     * baked into `cur`); an absent word holds the current logical position. With `off === 0` (the
+     * identity WCS + no G92) this reduces to the pre-#158 `word ?? cur`, so the corpus is byte-identical.
+     */
+    const nextAxis = (cur, word, off = 0) => xyzAbsolute ? (word !== undefined ? word + off : cur) : cur + (word ?? 0);
     // Floating origin (DD-001 §4.6): fixed at the first emitted segment's start.
     let originSet = false;
     let ox = 0;
@@ -158,7 +274,10 @@ export function createEngine(input, opts) {
                 kind,
                 tool: path?.tool ?? tool,
                 layer: UNRESOLVED_LAYER,
-                srcByte: currentSrcByte
+                srcByte: currentSrcByte,
+                // toolPower is the modal S while a tool is engaged; NaN when off (M5 / never engaged) — an
+                // honest "no cutting power here", not a fabricated 0. Only built when requested (DD-012 D3).
+                modal: wantToolPower ? { toolPower: toolEngaged ? modalS : NaN } : undefined
             });
         }
         catch (err) {
@@ -252,21 +371,27 @@ export function createEngine(input, opts) {
         prevY = sy;
         prevZ = sz;
     };
-    const g0 = (p) => {
+    // Map a resolved path type to its MoveKind bit (DD-012 D2). `cut` only ever arises on a feed move
+    // when the tool is engaged and E is absent, so FDM (never `cut`) is byte-identical.
+    const kindForPath = (t) => t === 'extrusion' ? MoveKind.Extrude : t === 'cut' ? MoveKind.Cut : MoveKind.Travel;
+    const g0 = (p, rapid) => {
         const { x, y, z, e, f } = p;
+        // Classify on the true per-move delta, not the raw E word (DD-010 D1). For the M83/relative
+        // corpus the delta equals the word, so output is byte-identical to the pre-E10 engine.
+        const eDelta = resolveEDelta(e);
         if (x === undefined && y === undefined && z === undefined) {
-            if (e > 0)
+            if (eDelta > 0)
                 stats.retractions++;
-            else if (e < 0)
+            else if (eDelta < 0)
                 stats.deretractions++;
             else if (f !== undefined)
                 stats.feedrateChanges++;
-            if (e !== undefined && e !== 0) {
+            if (e !== undefined && eDelta !== 0) {
                 retractionEvents.push({
                     x: sx,
                     y: sy,
                     z: sz,
-                    kind: e < 0 ? 'retract' : 'unretract',
+                    kind: eDelta < 0 ? 'retract' : 'unretract',
                     srcByte: currentSrcByte,
                     segIndex: writer.count
                 });
@@ -280,47 +405,78 @@ export function createEngine(input, opts) {
         stats.points++;
         if (f !== undefined)
             modalFeed = f;
-        const pathType = e > 0 ? 'extrusion' : 'travel';
+        // A rapid (G0) is a non-cutting positioning traverse — Travel even while the tool is engaged
+        // (a router keeps its spindle on during rapids; a GRBL-laser gates the beam off during G0). Only
+        // a FEED move (G1/G2/G3) with the tool engaged and no extrusion is a Cut (DD-012 D2, refined #189).
+        const pathType = eDelta > 0 ? 'extrusion' : toolEngaged && !rapid ? 'cut' : 'travel';
         if (path === null || path.type !== pathType) {
             breakPath(pathType);
         }
-        if (e > 0)
-            stats.extrusionDistance += e;
-        sx = x ?? sx;
-        sy = y ?? sy;
-        sz = z ?? sz;
-        return emitSegment(sx, sy, sz, e ?? 0, pathType === 'extrusion' ? MoveKind.Extrude : MoveKind.Travel);
+        if (eDelta > 0)
+            stats.extrusionDistance += eDelta;
+        sx = nextAxis(sx, x, offX());
+        sy = nextAxis(sy, y, offY());
+        sz = nextAxis(sz, z, offZ());
+        // An absolute commanded move re-establishes certainty for the axes it names (#158).
+        if (xyzAbsolute) {
+            if (x !== undefined)
+                certainX = true;
+            if (y !== undefined)
+                certainY = true;
+            if (z !== undefined)
+                certainZ = true;
+        }
+        g53OneShot = false; // one-shot machine-coordinate bypass consumed by this move
+        return emitSegment(sx, sy, sz, eDelta, kindForPath(pathType));
     };
     const g2 = (p, cw) => {
-        const { x, y, z, e, f } = p;
-        let { i, j, r } = p;
+        const { e, f } = p;
+        let { r } = p;
         if (f !== undefined)
             modalFeed = f;
-        const pathType = e ? 'extrusion' : 'travel';
+        // E is delta-based (DD-010 D1) so M82 arcs classify correctly and `lastE` stays consistent with g0.
+        const eDelta = resolveEDelta(e);
+        const pathType = eDelta ? 'extrusion' : toolEngaged ? 'cut' : 'travel';
         if (path === null || path.type !== pathType) {
             breakPath(pathType);
         }
-        if (e > 0)
-            stats.extrusionDistance += e;
+        if (eDelta > 0)
+            stats.extrusionDistance += eDelta;
+        // Absolute targets, honoring G90/G91 (DD-010 D2 — the deferred G91-arc geometry lands here, #157)
+        // and the active work offset (DD-010 D4, #158). I/J/K are ALWAYS current-relative center offsets.
+        const tx = nextAxis(sx, p.x, offX());
+        const ty = nextAxis(sy, p.y, offY());
+        const tz = nextAxis(sz, p.z, offZ());
+        g53OneShot = false; // one-shot machine-coordinate bypass consumed by this move
+        // Select the active arc plane (DD-010 D3): (sa,sb)→(ta,tb) is the in-plane arc with center offsets
+        // (oa,ob); sc→tc is the through axis (linear ramp). XY reproduces the pre-#157 math exactly, so the
+        // XY-arc corpus stays byte-identical; only G18/G19 arcs newly flatten in the correct plane.
+        const [sa, sb, sc, ta, tb, tc, oa, ob] = arcPlane === 'xz'
+            ? [sx, sz, sy, tx, tz, ty, p.i, p.k]
+            : arcPlane === 'yz'
+                ? [sy, sz, sx, ty, tz, tx, p.j, p.k]
+                : [sx, sy, sz, tx, ty, tz, p.i, p.j];
+        let ia = oa;
+        let ib = ob;
         if (r) {
-            const deltaX = x - sx; // assume abs mode (inherited)
-            const deltaY = y - sy;
-            const minR = Math.sqrt(Math.pow(deltaX / 2, 2) + Math.pow(deltaY / 2, 2));
+            const deltaA = ta - sa;
+            const deltaB = tb - sb;
+            const minR = Math.sqrt(Math.pow(deltaA / 2, 2) + Math.pow(deltaB / 2, 2));
             r = Math.max(r, minR);
-            const dSquared = Math.pow(deltaX, 2) + Math.pow(deltaY, 2);
+            const dSquared = Math.pow(deltaA, 2) + Math.pow(deltaB, 2);
             const hSquared = Math.pow(r, 2) - dSquared / 4;
             let hDivD = Math.sqrt(hSquared / dSquared);
             if ((cw && r < 0.0) || (!cw && r > 0.0))
                 hDivD = -hDivD;
-            i = deltaX / 2 + deltaY * hDivD;
-            j = deltaY / 2 - deltaX * hDivD;
-        }
-        const wholeCircle = sx == x && sy == y;
-        const centerX = sx + i;
-        const centerY = sy + j;
-        const arcRadius = Math.sqrt(i * i + j * j);
-        const arcCurrentAngle = Math.atan2(-j, -i);
-        const finalTheta = Math.atan2(y - centerY, x - centerX);
+            ia = deltaA / 2 + deltaB * hDivD;
+            ib = deltaB / 2 - deltaA * hDivD;
+        }
+        const wholeCircle = sa == ta && sb == tb;
+        const centerA = sa + ia;
+        const centerB = sb + ib;
+        const arcRadius = Math.sqrt(ia * ia + ib * ib);
+        const arcCurrentAngle = Math.atan2(-ib, -ia);
+        const finalTheta = Math.atan2(tb - centerB, ta - centerA);
         let totalArc;
         if (wholeCircle) {
             totalArc = 2 * Math.PI;
@@ -337,26 +493,70 @@ export function createEngine(input, opts) {
             totalSegments = 1;
         let arcAngleIncrement = totalArc / totalSegments;
         arcAngleIncrement *= cw ? -1 : 1;
-        const zDist = sz - (z || sz);
-        const zStep = zDist / totalSegments;
-        const kind = (pathType === 'extrusion' ? MoveKind.Extrude : MoveKind.Travel) | MoveKind.ArcSegment;
-        const eachE = e !== undefined ? e / Math.max(1, Math.ceil(totalSegments)) : 0;
-        let px;
-        let py;
-        let pz = sz;
+        // Through-axis linear ramp — preserves the inherited step (byte-identical for planar XY arcs,
+        // where the through axis is unchanged so the ramp is flat).
+        const cStep = (sc - tc) / totalSegments;
+        const kind = kindForPath(pathType) | MoveKind.ArcSegment;
+        const eachE = e !== undefined ? eDelta / Math.max(1, Math.ceil(totalSegments)) : 0;
+        // Map an in-plane point (pa,pb) + through-axis pc back to (x,y,z) for the active plane.
+        const emitArc = (pa, pb, pcv) => {
+            const [px, py, pz] = arcPlane === 'xz' ? [pa, pcv, pb] : arcPlane === 'yz' ? [pcv, pa, pb] : [pa, pb, pcv];
+            return emitSegment(px, py, pz, eachE, kind);
+        };
+        let pc = sc;
         let currentAngle = arcCurrentAngle;
         for (let moveIdx = 0; moveIdx < totalSegments - 1; moveIdx++) {
             currentAngle += arcAngleIncrement;
-            px = centerX + arcRadius * Math.cos(currentAngle);
-            py = centerY + arcRadius * Math.sin(currentAngle);
-            pz += zStep;
-            if (!emitSegment(px, py, pz, eachE, kind))
+            const pa = centerA + arcRadius * Math.cos(currentAngle);
+            const pb = centerB + arcRadius * Math.sin(currentAngle);
+            pc += cStep;
+            if (!emitArc(pa, pb, pc))
                 return false;
         }
-        sx = x || sx;
-        sy = y || sy;
-        sz = z || sz;
-        return emitSegment(sx, sy, sz, eachE, kind);
+        sx = tx;
+        sy = ty;
+        sz = tz;
+        return emitArc(ta, tb, tc);
+    };
+    // Canned drilling cycle (DD-012 phase 2, #189): expand G81/G82/G83 into explicit sub-moves so the
+    // holes are real geometry (today they emit nothing). Rapids are Travel; the plunge(s) are Cut. Z/R/Q
+    // and the initial plane are captured when the cycle is defined and retained across modal repeats.
+    const runCannedCycle = (p) => {
+        // 1. Rapid to the hole XY at the current Z.
+        sx = nextAxis(sx, p.x, offX());
+        sy = nextAxis(sy, p.y, offY());
+        g53OneShot = false;
+        if (!emitSegment(sx, sy, sz, 0, MoveKind.Travel))
+            return false;
+        // 2. Rapid Z down to the R (reference) plane.
+        sz = cannedR;
+        if (!emitSegment(sx, sy, sz, 0, MoveKind.Travel))
+            return false;
+        // 3. Feed to depth — one plunge (G81/G82) or a peck loop (G83). Productive → Cut.
+        if (cannedCycle === 'g83' && cannedQ > 0 && cannedR > cannedZ) {
+            let depth = cannedR;
+            while (depth > cannedZ) {
+                depth = Math.max(cannedZ, depth - cannedQ);
+                sz = depth;
+                if (!emitSegment(sx, sy, sz, 0, MoveKind.Cut))
+                    return false; // feed down one peck
+                if (depth > cannedZ) {
+                    sz = cannedR;
+                    if (!emitSegment(sx, sy, sz, 0, MoveKind.Travel))
+                        return false; // rapid retract to R between pecks
+                }
+            }
+        }
+        else {
+            sz = cannedZ;
+            if (!emitSegment(sx, sy, sz, 0, MoveKind.Cut))
+                return false; // single plunge
+        }
+        // 4. Retract (rapid) to the initial plane (G98) or the R plane (G99).
+        sz = cannedRetractInitial ? cannedInitialZ : cannedR;
+        if (!emitSegment(sx, sy, sz, 0, MoveKind.Travel))
+            return false;
+        return true;
     };
     const onComment = opts.onComment;
     const onCommand = opts.onCommand;
@@ -374,56 +574,266 @@ export function createEngine(input, opts) {
                 onComment(rawLine.slice(ci + 1), offset);
         }
         const cmd = lexLine(rawLine);
-        if (cmd.gcode === '')
-            return;
-        stats.commands++;
-        if (onCommand !== undefined) {
-            onCommand({ gcode: cmd.gcode, params: cmd.params, rawLine, srcByte: offset, segIndex: writer.count });
+        // Skip only genuinely empty lines. A line with no lexable words but real content (a dialect
+        // extended command like `EXCLUDE_OBJECT_START NAME=cube`, a macro) must NOT be dropped — the
+        // observer below still forwards its raw line. The body split runs only when there are no words.
+        if (cmd.codes.length === 0 && Object.keys(cmd.params).length === 0 && rawLine.split(';')[0].trim() === '') {
+            return; // blank or comment-only line
         }
+        stats.commands++;
+        // Modal S/F latch from params on ANY line — including bare `S1000` / `F600` lines that carry no
+        // command word (common in GRBL-laser output). S is captured for toolPower only when requested.
+        if (wantToolPower && cmd.params.s !== undefined)
+            modalS = cmd.params.s;
+        if (cmd.params.f !== undefined)
+            modalFeed = cmd.params.f;
         let ok = true;
-        switch (cmd.gcode) {
-            case 'g0':
-            case 'g1':
-                ok = g0(cmd.params);
-                break;
-            case 'g2':
-                ok = g2(cmd.params, true);
-                break;
-            case 'g3':
-                ok = g2(cmd.params, false);
-                break;
-            case 'g20':
-                units = 'in';
-                unitsSeen = true;
-                break;
-            case 'g21':
-                units = 'mm';
-                unitsSeen = true;
-                break;
-            case 'g28':
-                sx = 0;
-                sy = 0;
-                sz = 0;
-                break;
-            case 't0':
-            case 't1':
-            case 't2':
-            case 't3':
-            case 't4':
-            case 't5':
-            case 't6':
-            case 't7':
-                tool = Number(cmd.gcode.slice(1));
-                break;
-            case 'm600':
-                // Manual filament swap = color boundary (#147). A marker, not motion — do
-                // NOT break/finish the current path; record position (current head), the
-                // next segment index (slot boundary), and the active tool for provenance.
-                colorChangeEvents.push({ x: sx, y: sy, z: sz, segIndex: writer.count, srcByte: offset, tool });
-                break;
-            default:
-                warn('unsupported-command', `unsupported command '${cmd.gcode}' preserved as metadata`, offset);
+        if (cmd.codes.length === 0) {
+            // No G/M/T command word. This is either a dialect extended command (EXCLUDE_OBJECT_*, macros —
+            // matched on the raw line, DD-005) or a bare motion/param line. Forward the raw line to the
+            // observer so dialects still see it, then continue the active modal motion group if the line
+            // carries motion axes (the CNC/LinuxCNC modal form; FDM always emits the G word, so this never
+            // runs for FDM — byte-identical).
+            if (onCommand !== undefined) {
+                onCommand({ gcode: '', params: cmd.params, rawLine, srcByte: offset, segIndex: writer.count });
+            }
+            if (cmd.params.x !== undefined || cmd.params.y !== undefined || cmd.params.z !== undefined) {
+                if (cannedCycle !== null)
+                    ok = runCannedCycle(cmd.params);
+                else if (modalMotion === 'g2' || modalMotion === 'g3')
+                    ok = g2(cmd.params, modalMotion === 'g2');
+                else if (modalMotion === 'g0' || modalMotion === 'g1')
+                    ok = g0(cmd.params, modalMotion === 'g0');
+            }
         }
+        else
+            for (const gcode of cmd.codes) {
+                if (onCommand !== undefined) {
+                    onCommand({ gcode, params: cmd.params, rawLine, srcByte: offset, segIndex: writer.count });
+                }
+                switch (gcode) {
+                    case 'g0':
+                    case 'g1':
+                        modalMotion = gcode;
+                        cannedCycle = null; // a G0–G3 motion command cancels the canned-cycle modal group
+                        ok = g0(cmd.params, gcode === 'g0');
+                        break;
+                    case 'g2':
+                        modalMotion = 'g2';
+                        cannedCycle = null;
+                        ok = g2(cmd.params, true);
+                        break;
+                    case 'g3':
+                        modalMotion = 'g3';
+                        cannedCycle = null;
+                        ok = g2(cmd.params, false);
+                        break;
+                    // Canned drilling cycles (DD-012 phase 2, #189). A fresh G81/G82/G83 captures Z/R/Q + the
+                    // initial plane and drills the first hole; bare X/Y lines (cannedRepeat) drill more, retaining
+                    // that state; G80 cancels; G98/G99 set the retract plane.
+                    case 'g81':
+                    case 'g82':
+                    case 'g83':
+                        cannedCyclesSeen = true;
+                        cannedCycle = gcode;
+                        cannedInitialZ = sz;
+                        if (cmd.params.z !== undefined)
+                            cannedZ = nextAxis(sz, cmd.params.z, offZ());
+                        if (cmd.params.r !== undefined)
+                            cannedR = nextAxis(sz, cmd.params.r, offZ());
+                        if (cmd.params.q !== undefined)
+                            cannedQ = Math.abs(cmd.params.q);
+                        modalMotion = null;
+                        ok = runCannedCycle(cmd.params);
+                        break;
+                    case 'g80':
+                        cannedCycle = null;
+                        break;
+                    case 'g98':
+                        cannedRetractInitial = true;
+                        break;
+                    case 'g99':
+                        cannedRetractInitial = false;
+                        break;
+                    case 'g20':
+                        units = 'in';
+                        unitsSeen = true;
+                        break;
+                    case 'g21':
+                        units = 'mm';
+                        unitsSeen = true;
+                        break;
+                    case 'g28':
+                        sx = 0;
+                        sy = 0;
+                        sz = 0;
+                        break;
+                    case 't0':
+                    case 't1':
+                    case 't2':
+                    case 't3':
+                    case 't4':
+                    case 't5':
+                    case 't6':
+                    case 't7':
+                        tool = Number(gcode.slice(1));
+                        break;
+                    case 'm600':
+                        // Manual filament swap = color boundary (#147). A marker, not motion — do
+                        // NOT break/finish the current path; record position (current head), the
+                        // next segment index (slot boundary), and the active tool for provenance.
+                        colorChangeEvents.push({ x: sx, y: sy, z: sz, segIndex: writer.count, srcByte: offset, tool });
+                        break;
+                    // Motion-model modal commands (DD-010 E10 phase 1).
+                    case 'g90':
+                        xyzAbsolute = true;
+                        positioningSeen = true;
+                        break;
+                    case 'g91':
+                        xyzAbsolute = false;
+                        positioningSeen = true;
+                        break;
+                    // Arc-plane selection (DD-010 D3, #157, E10 phase 2).
+                    case 'g17':
+                        arcPlane = 'xy';
+                        arcPlaneSeen = true;
+                        break;
+                    case 'g18':
+                        arcPlane = 'xz';
+                        arcPlaneSeen = true;
+                        break;
+                    case 'g19':
+                        arcPlane = 'yz';
+                        arcPlaneSeen = true;
+                        break;
+                    case 'm82':
+                        eModeExplicit = 'absolute';
+                        break;
+                    case 'm83':
+                        eModeExplicit = 'relative';
+                        break;
+                    // Tool-state modal (DD-012 D2/D4, #189). M3 (CW) / M4 (CCW) engage the spindle/laser;
+                    // M5 disengages. Drives Cut-vs-Travel classification for non-extrusion moves. The `S` word
+                    // (power/RPM) is a modal channel handled in a later phase; here we track only engagement.
+                    case 'm3':
+                    case 'm4':
+                        toolEngaged = true;
+                        toolStateSeen = true;
+                        break;
+                    case 'm5':
+                        toolEngaged = false;
+                        toolStateSeen = true;
+                        break;
+                    // Coordinate systems (DD-010 D4, #158, E10 phase 3).
+                    case 'g53':
+                        // One-shot: the following move is in machine coordinates (ignores the work offset).
+                        g53OneShot = true;
+                        coordSystemSeen = true;
+                        break;
+                    case 'g54':
+                    case 'g55':
+                    case 'g56':
+                    case 'g57':
+                    case 'g58':
+                    case 'g59':
+                        activeWcs = Number(gcode.slice(1)) - 54; // g54→0 … g59→5
+                        coordSystemSeen = true;
+                        break;
+                    case 'g10': {
+                        // Set a work-coordinate offset. L2 P<n>: set the offset directly. L20 P<n>: set it so the
+                        // current position reads the given value in WCS n. P1→G54 … P6→G59 (default: active system).
+                        const l = cmd.params.l;
+                        const idx = cmd.params.p !== undefined ? Math.round(cmd.params.p) - 1 : activeWcs;
+                        if (idx >= 0 && idx < 6 && (l === 2 || l === 20)) {
+                            const w = wcsOffsets[idx];
+                            const setAxis = (word, cur, axis) => {
+                                if (word === undefined)
+                                    return;
+                                w[axis] = l === 2 ? word : cur - word; // L20: offset = current logical − desired reading
+                            };
+                            setAxis(cmd.params.x, sx, 'x');
+                            setAxis(cmd.params.y, sy, 'y');
+                            setAxis(cmd.params.z, sz, 'z');
+                            coordSystemSeen = true;
+                        }
+                        break;
+                    }
+                    case 'g31': {
+                        // Probe move (DD-010 D4 amendment, #158): the endpoint is reached at RUNTIME (workpiece
+                        // contact), NOT the commanded value. Do not advance the position or draw a fabricated probe
+                        // move; mark the probed axes runtime-dependent so a following G92 resyncs the logical frame.
+                        let probed = false;
+                        if (cmd.params.x !== undefined) {
+                            certainX = false;
+                            probed = true;
+                        }
+                        if (cmd.params.y !== undefined) {
+                            certainY = false;
+                            probed = true;
+                        }
+                        if (cmd.params.z !== undefined) {
+                            certainZ = false;
+                            probed = true;
+                        }
+                        if (probed) {
+                            warn('probe-position-runtime-dependent', 'G31 probe endpoint is determined at runtime; the probed axis is runtime-dependent until re-established (G92 or an absolute move).', offset);
+                        }
+                        break;
+                    }
+                    case 'g92': {
+                        // Datum WITHOUT motion (DD-010 D4 + probe amendment, #158). `G92 E<v>` rebases the absolute-E
+                        // origin (also used in phase 1). For X/Y/Z, when the position is KNOWN it is a datum SHIFT (the
+                        // work offset is set so the current logical position reads <v>, preserving continuity). When the
+                        // axis is runtime-dependent (post-probe) it is a logical RESYNC: the current logical position is
+                        // declared to be <v>, the offset is reset, certainty is restored, and the current path is
+                        // finalized so the next move starts a NEW frame at the datum — no fabricated move is drawn
+                        // across the unknown probe result.
+                        if (cmd.params.e !== undefined)
+                            lastE = cmd.params.e;
+                        let resync = false;
+                        if (cmd.params.x !== undefined) {
+                            if (certainX)
+                                g92x = sx - cmd.params.x - wcsOffsets[activeWcs].x;
+                            else {
+                                sx = cmd.params.x + wcsOffsets[activeWcs].x;
+                                g92x = 0;
+                                certainX = true;
+                                resync = true;
+                            }
+                            coordSystemSeen = true;
+                        }
+                        if (cmd.params.y !== undefined) {
+                            if (certainY)
+                                g92y = sy - cmd.params.y - wcsOffsets[activeWcs].y;
+                            else {
+                                sy = cmd.params.y + wcsOffsets[activeWcs].y;
+                                g92y = 0;
+                                certainY = true;
+                                resync = true;
+                            }
+                            coordSystemSeen = true;
+                        }
+                        if (cmd.params.z !== undefined) {
+                            if (certainZ)
+                                g92z = sz - cmd.params.z - wcsOffsets[activeWcs].z;
+                            else {
+                                sz = cmd.params.z + wcsOffsets[activeWcs].z;
+                                g92z = 0;
+                                certainZ = true;
+                                resync = true;
+                            }
+                            coordSystemSeen = true;
+                        }
+                        if (resync)
+                            finishPath(); // start a new frame at the datum; no move connects across the probe
+                        break;
+                    }
+                    default:
+                        warn('unsupported-command', `unsupported command '${gcode}' preserved as metadata`, offset);
+                }
+                if (!ok)
+                    break;
+            }
         if (!ok) {
             truncatedAtByte = offset;
         }
@@ -463,8 +873,33 @@ export function createEngine(input, opts) {
             featureRoles: 'unavailable',
             objects: 'unavailable',
             retractions: retractionEvents.length > 0 ? 'known' : 'unavailable',
-            colorChanges: colorChangeEvents.length > 0 ? 'known' : 'unavailable'
+            colorChanges: colorChangeEvents.length > 0 ? 'known' : 'unavailable',
+            // Annotation-derived move kinds (DD-016, #182). The parser never sets these — they come from a
+            // slicer adapter's WIPE_START/END brackets (upgraded to 'known' via the sink). Seam has no
+            // per-move G-code signal and stays 'unavailable' (a future geometry-heuristic DD may change it).
+            wipeMoves: 'unavailable',
+            seamMoves: 'unavailable',
+            // Non-extrusion productive moves (DD-012 D2, #189). 'known' once a tool-state modal (M3/M4/M5)
+            // was seen — i.e. this is a CNC/laser/plotter file whose Cut moves are meaningful; 'unavailable'
+            // for FDM (no tool-state), where every move is Extrude/Travel and Cut is never set.
+            cutMoves: toolStateSeen ? 'known' : 'unavailable',
+            // Canned drilling cycles expanded to geometry (DD-012 phase 2, #189). 'known' once a G81/G82/G83
+            // was seen (holes are real segments), else 'unavailable' (no cycles / FDM).
+            cannedCycles: cannedCyclesSeen ? 'known' : 'unavailable',
+            // Motion-model modes (DD-010 E10 phase 1). 'known' when the governing command was seen
+            // (M82/M83, or a firmware-known G90/G91 for E); 'inferred' when defaulted (absolute).
+            extrusionMode: eModeExplicit !== null || (extruderFollowsPositioning && positioningSeen) ? 'known' : 'inferred',
+            positioningMode: positioningSeen ? 'known' : 'inferred',
+            // Arc plane (DD-010 D3, #157): 'known' once a G17/G18/G19 was seen, else 'inferred' (XY assumed).
+            arcPlanes: arcPlaneSeen ? 'known' : 'inferred',
+            // Coordinate system (DD-010 D4, #158): 'known' once a G53/G54–G59/G92-XYZ/G10 was seen, else
+            // 'inferred' (identity WCS / no offset assumed — the FDM-slicer default).
+            coordinateSystem: coordSystemSeen ? 'known' : 'inferred'
         };
+        // Opt-in modal channels (DD-012 D3): only surfaced when requested. 'known' once its controlling
+        // signal was seen (toolPower ← a tool-state modal), else 'unavailable' — never a fabricated value.
+        if (wantToolPower)
+            capabilities.toolPower = toolStateSeen ? 'known' : 'unavailable';
         if (layersCapability === 'unavailable') {
             warn('layers-unavailable', 'No planar layer index; all segments assigned to layer 0.');
         }
@@ -564,7 +999,15 @@ export function createEngine(input, opts) {
                     featureRoles: 'unavailable',
                     objects: 'unavailable',
                     retractions: 'unavailable', // markers resolve on the final IR, not on preview slices
-                    colorChanges: 'unavailable' // color-change boundaries resolve on the final IR
+                    colorChanges: 'unavailable', // color-change boundaries resolve on the final IR
+                    wipeMoves: 'unavailable', // annotation move kinds resolve on the final IR (DD-016)
+                    seamMoves: 'unavailable',
+                    cutMoves: 'unavailable', // non-extrusion classification resolves on the final IR (DD-012)
+                    cannedCycles: 'unavailable', // canned-cycle expansion resolves on the final IR (DD-012)
+                    extrusionMode: 'inferred', // motion modes resolve fully on the final IR (E10)
+                    positioningMode: 'inferred',
+                    arcPlanes: 'inferred',
+                    coordinateSystem: 'inferred'
                 }
             },
             segments: channels,

package/dist/worker.js

@@ -10,8 +10,9 @@
  * `worker-slim.ts`; custom adapters use a consumer-supplied worker entry
  * calling `createWorkerHandler(post, { dialects: createDialectRunner([...]) })`.
  */
-import { createDialectRunner, cura, klipper, marlin, orcaBambu, prusaSlicer, repRap } from '@chestnutlabs/gcode-dialects';
+import { createDialectRunner, cura, grblLaser, grblMill, klipper, linuxCnc, marlin, orcaBambu, prusaSlicer, repRap } from '@chestnutlabs/gcode-dialects';
 import { openGcode3mf, sniffGcode3mf } from '@chestnutlabs/gcode-containers';
+import { openBgcodeContainer, sniffBgcode } from '@chestnutlabs/gcode-bgcode';
 import { createWorkerHandler } from './worker-core.js';
 /** Built-in dialect adapter set (DD-005 phases 3–4; phase 5 adds command semantics). */
 const BUILTIN_ADAPTERS = [
@@ -20,11 +21,16 @@ const BUILTIN_ADAPTERS = [
     cura(),
     klipper(),
     marlin(),
-    repRap()
+    repRap(),
+    // Non-extrusion controllers (DD-012 phase 3, #189) — all EXPERIMENTAL tier until hardware-validated.
+    grblLaser(),
+    grblMill(),
+    linuxCnc()
 ];
-/** Built-in container adapters (DD-005 §4.4): .gcode.3mf. */
+/** Built-in container adapters (DD-005 §4.4): .gcode.3mf and Prusa binary G-code (.bgcode, #188). */
 const BUILTIN_CONTAINERS = [
-    { id: 'gcode-3mf', sniff: sniffGcode3mf, open: (bytes) => openGcode3mf(bytes) }
+    { id: 'gcode-3mf', sniff: sniffGcode3mf, open: (bytes) => openGcode3mf(bytes) },
+    { id: 'bgcode', sniff: (prefix) => sniffBgcode(prefix), open: (bytes) => openBgcodeContainer(bytes) }
 ];
 const post = (msg, transfer) => self.postMessage(msg, transfer);
 const handle = createWorkerHandler(post, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chestnutlabs/gcode-parser",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Worker-safe G-code parse core producing ToolpathIR (DD-003).",
   "keywords": [
     "gcode",
@@ -49,8 +49,9 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@chestnutlabs/toolpath-core": "0.2.0",
-    "@chestnutlabs/gcode-dialects": "0.2.0",
-    "@chestnutlabs/gcode-containers": "0.2.0"
+    "@chestnutlabs/toolpath-core": "0.4.0",
+    "@chestnutlabs/gcode-dialects": "0.4.0",
+    "@chestnutlabs/gcode-containers": "0.4.0",
+    "@chestnutlabs/gcode-bgcode": "0.4.0"
   }
 }