@chestnutlabs/gcode-parser 0.16.0 → 0.18.0

package/dist/parse.d.ts

@@ -34,6 +34,19 @@ export interface ParseLimits {
     maxBufferBytes: number;
     maxLineLength: number;
     maxWarnings: number;
+    /**
+     * Total loop work across an RS274NGC O-word program (DD-017 §4.5, Phase 2). Charged per loop pass and
+     * per statement executed inside a loop body; exceeding it stops the program with a partial IR and a
+     * `rs274-iteration-limit` disclosure, so a hostile `o while [1]` wastes only bounded CPU. Irrelevant to
+     * FDM / non-parametric input, which never enters the interpreter.
+     */
+    maxProgramIterations: number;
+    /**
+     * Subroutine call-recursion depth for an RS274NGC O-word program (DD-017 §4.5, Phase 3). A `call` that
+     * would exceed this depth is disclosed (`rs274-call-depth`) and skipped, so unbounded recursion cannot
+     * exhaust the stack. Irrelevant to FDM / non-parametric input.
+     */
+    maxCallDepth: number;
 }
 export declare const DEFAULT_LIMITS: ParseLimits;
 /**
@@ -144,6 +157,18 @@ export interface Engine {
     processLine(rawLine: string, offset: number): void;
     stopped(): boolean;
     markInputTooBig(): void;
+    /**
+     * Interpret the buffered `text` as an RS274NGC O-word program (DD-017 Phase 2). Called by the
+     * in-memory drivers INSTEAD of the forward-only line loop when `programUsesOWords(text)` is true;
+     * the interpreter re-feeds every plain line through `processLine`, so geometry stays on one path.
+     */
+    runOWordFlow(): void;
+    /**
+     * Streaming only: record that an O-word control line was seen but NOT interpreted (control flow needs a
+     * fully-buffered program — DD-017 §4.1). Discloses once and marks the parametric capability degraded;
+     * the line still runs linearly (the honest pre-Phase-2 behaviour), never silently as if flow had run.
+     */
+    noteUninterpretedOWord(srcByte: number): void;
     /** Streaming driver: record the true source byte count as it becomes known. */
     setSourceBytes(bytes: number): void;
     /**

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

@@ -27,14 +27,18 @@
  * output; multi-byte comment bytes would skew offsets and are a documented
  * limitation until the streaming decoder lands (phase 3).
  */
-import { IR_SCHEMA_VERSION, MoveKind, buildSourceIndex, computeSegmentBounds } from '@chestnutlabs/toolpath-core';
+import { IR_SCHEMA_VERSION, MoveKind, buildSourceIndex, classifyModelBounds, computeSegmentBounds, emptyBounds } from '@chestnutlabs/toolpath-core';
 import { BudgetExceededError, SegmentWriter } from './growable.js';
+import { Rs274Context, lineUsesParametric } from './rs274.js';
+import { RS274_FLOW_WARN, interpretOWordProgram, programUsesOWords } from './rs274-flow.js';
 export const DEFAULT_LIMITS = {
     maxInputBytes: 512 * 1024 * 1024,
     maxSegments: 20_000_000,
     maxBufferBytes: 1536 * 1024 * 1024,
     maxLineLength: 64 * 1024,
-    maxWarnings: 10_000
+    maxWarnings: 10_000,
+    maxProgramIterations: 1_000_000,
+    maxCallDepth: 50
 };
 const LAYER_TOLERANCE = 0.05;
 const UNRESOLVED_LAYER = 0xffffffff;
@@ -186,6 +190,10 @@ export function createEngine(input, opts) {
     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'
+    // RS274NGC parametric programs (DD-017 Phase 1, #189 phase 7). The store + expression evaluator resolve
+    // `#params`/`[expr]` on any line that uses them; non-parametric lines never touch it (byte-identical).
+    // The system-parameter allow-list (#5420–#5422 = current position) reads live engine position.
+    const rs274 = new Rs274Context(warn, () => ({ x: sx, y: sy, z: sz }));
     // 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
@@ -573,7 +581,22 @@ export function createEngine(input, opts) {
             if (ci !== -1)
                 onComment(rawLine.slice(ci + 1), offset);
         }
-        const cmd = lexLine(rawLine);
+        // RS274NGC parametric programs (DD-017 Phase 1): a line using `#`/`[` is resolved by the parameter +
+        // expression interpreter; a `#n = <expr>` assignment executes and the line ends there. Every other
+        // line (all FDM, all simple CNC) takes the untouched lexer below — byte-identical.
+        let cmd;
+        // Hot-path gate: a cheap `#`/`[` scan of the RAW line — no allocation. Every FDM line fails this and
+        // takes the untouched lexer (byte-identical). A `#`/`[` that turns out to be only inside a comment
+        // routes through the resolver, which strips comments and returns 'plain' → the normal lexer.
+        if (lineUsesParametric(rawLine)) {
+            const r = rs274.lexLine(rawLine, offset);
+            if (r.kind === 'assign' || r.kind === 'empty')
+                return; // assignment applied / nothing to do
+            cmd = r.kind === 'cmd' ? { codes: r.codes, params: r.params } : lexLine(rawLine); // 'plain' → normal
+        }
+        else {
+            cmd = lexLine(rawLine);
+        }
         // 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.
@@ -838,6 +861,46 @@ export function createEngine(input, opts) {
             truncatedAtByte = offset;
         }
     };
+    // RS274NGC O-word control flow (DD-017 Phase 2). Engaged only when the buffered program actually
+    // contains a control line; it buffers the lines with their byte offsets and hands them to the tree
+    // interpreter, which re-feeds each plain line through `processLine` (one geometry path) and evaluates
+    // conditions/counts against the SAME parameter store. `used`/`degraded` tier the capability.
+    const runOWordFlow = () => {
+        rs274.used = true;
+        const flowLines = [];
+        const len = text.length;
+        let offset = 0;
+        while (offset < len) {
+            let nl = text.indexOf('\n', offset);
+            if (nl === -1)
+                nl = len;
+            flowLines.push({ text: text.slice(offset, nl), offset });
+            offset = nl + 1;
+        }
+        const { degraded } = interpretOWordProgram(flowLines, {
+            processLine,
+            stopped: () => stopReason !== undefined,
+            evalExpression: (t, b) => rs274.evalExpression(t, b),
+            pushScope: (args) => rs274.pushScope(args),
+            popScope: () => rs274.popScope(),
+            warn,
+            maxProgramIterations: limits.maxProgramIterations,
+            maxCallDepth: limits.maxCallDepth
+        });
+        if (degraded)
+            rs274.degraded = true;
+    };
+    // Streaming can't interpret control flow from a partial stream (a loop needs its whole body — DD-017
+    // §4.1); disclose once and let the program run linearly (control lines are inert). Honest, bounded.
+    let streamingOWordWarned = false;
+    const noteUninterpretedOWord = (srcByte) => {
+        if (streamingOWordWarned)
+            return;
+        streamingOWordWarned = true;
+        rs274.used = true;
+        rs274.degraded = true;
+        warn(RS274_FLOW_WARN.streamingUnsupported, 'O-word control flow is only interpreted for fully-buffered input; this streamed program ran linearly (control flow not executed).', srcByte);
+    };
     const finish = (cancelledAtByte) => {
         if (stopReason !== undefined && truncatedAtByte === undefined) {
             truncatedAtByte = currentSrcByte;
@@ -854,6 +917,7 @@ export function createEngine(input, opts) {
         stats.segments = segments.count;
         const origin = { x: ox, y: oy, z: oz };
         const { bounds, boundsWithTravel, objectBounds } = computeSegmentBounds(segments, origin);
+        const { modelBounds, classification: nonModelClassification } = classifyModelBounds(segments, origin);
         const sourceIndex = buildSourceIndex(segments.srcByte, segments.count);
         // Layer table for the IR (absolute z; seg ranges accumulated above).
         const irLayers = layersCleared || layers.length === 0
@@ -872,6 +936,10 @@ export function createEngine(input, opts) {
             sourcePositions: 'known',
             featureRoles: 'unavailable',
             objects: 'unavailable',
+            // Non-model (model-bounds) classification (DD-026 D7). At parse time the object/feature channels
+            // are usually empty, so this is 'unavailable' until a dialect adapter annotates them and the
+            // runner refreshes it (gcode-dialects finalize). Honest either way — never a guess.
+            nonModelClassification,
             retractions: retractionEvents.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
@@ -886,6 +954,11 @@ export function createEngine(input, opts) {
             // 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',
+            // RS274NGC parametric programs (DD-017, #189 phase 7). 'known' once a `#param`/`[expr]`/O-word was
+            // executed deterministically within limits (the interpreter computes geometry — it does not infer);
+            // 'approximated' when Phase 2 flow was degraded (a hit iteration cap, an unbalanced/unsupported
+            // O-word, or a malformed condition — always disclosed); 'unavailable' for non-parametric input.
+            parametricProgram: rs274.parametricConfidence(),
             // 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',
@@ -945,6 +1018,7 @@ export function createEngine(input, opts) {
             bounds,
             boundsWithTravel,
             objectBounds,
+            modelBounds,
             sourceIndex
         };
         if (stopReason !== undefined) {
@@ -999,12 +1073,14 @@ export function createEngine(input, opts) {
                     sourcePositions: 'unavailable', // no per-slice source index is built
                     featureRoles: 'unavailable',
                     objects: 'unavailable',
+                    nonModelClassification: 'unavailable', // model classification resolves on the final IR (DD-026)
                     retractions: 'unavailable', // markers resolve on the final IR, not on preview slices
                     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)
+                    parametricProgram: 'unavailable', // parametric resolution resolves on the final IR (DD-017)
                     extrusionMode: 'inferred', // motion modes resolve fully on the final IR (E10)
                     positioningMode: 'inferred',
                     arcPlanes: 'inferred',
@@ -1020,6 +1096,7 @@ export function createEngine(input, opts) {
             bounds,
             boundsWithTravel,
             objectBounds,
+            modelBounds: emptyBounds(),
             sourceIndex: { byteOffsets: new Uint32Array(0), segmentIndices: new Uint32Array(0) }
         };
         return { slice, upTo: cut };
@@ -1029,6 +1106,8 @@ export function createEngine(input, opts) {
         limits,
         processLine,
         stopped: () => stopReason !== undefined,
+        runOWordFlow,
+        noteUninterpretedOWord,
         snapshot,
         markInputTooBig: () => {
             stopReason = {
@@ -1054,6 +1133,13 @@ export function parseGcodeToIR(input, opts = {}) {
         return engine.finish();
     }
     const text = engine.text;
+    // RS274NGC O-word program (DD-017 Phase 2): interpret with control flow instead of the forward-only
+    // loop. The cheap detection scan fails for every FDM / non-parametric file, which takes the untouched
+    // loop below (byte-identical).
+    if (programUsesOWords(text)) {
+        engine.runOWordFlow();
+        return engine.finish();
+    }
     const len = text.length;
     let offset = 0;
     while (offset < len && !engine.stopped()) {
@@ -1093,6 +1179,14 @@ export async function parseGcodeToIRAsync(input, opts = {}, hooks = {}) {
     const yieldEvery = hooks.yieldIntervalMs ?? 50;
     const partial = makePartialEmitter(engine, hooks);
     const text = engine.text;
+    // RS274NGC O-word program (DD-017 Phase 2): a bounded synchronous interpretation section (loops are
+    // capped by `maxProgramIterations`, and these programs are small — hand/CAM-written). Non-parametric
+    // input takes the cooperative line loop below unchanged.
+    if (programUsesOWords(text)) {
+        engine.runOWordFlow();
+        hooks.onProgress?.(text.length, byteLength, 0);
+        return { ...engine.finish(), cancelled: false };
+    }
     const len = text.length;
     let offset = 0;
     let sliceStart = Date.now();

package/dist/rs274-flow.d.ts

@@ -0,0 +1,69 @@
+/** Warning codes surfaced to the IR by the flow interpreter (DD-017 §4.6). */
+export declare const RS274_FLOW_WARN: {
+    readonly iterationLimit: "rs274-iteration-limit";
+    readonly unbalancedOword: "rs274-unbalanced-oword";
+    readonly unsupportedOword: "rs274-unsupported-oword";
+    readonly controlNesting: "rs274-control-nesting";
+    readonly misplacedControl: "rs274-misplaced-control";
+    readonly streamingUnsupported: "rs274-streaming-flow-unsupported";
+    readonly callDepth: "rs274-call-depth";
+    readonly unknownSub: "rs274-unknown-sub";
+    readonly duplicateSub: "rs274-duplicate-sub";
+};
+/** The recognized O-word keywords. An `o<id>` line with any OTHER trailing word is NOT a control line
+ *  (e.g. a stray `o5 g1`) — it falls through to the normal lexer, so detection never hijacks plain code. */
+export declare const KNOWN_OWORD_KEYWORDS: ReadonlySet<string>;
+export type WarnFn = (code: string, message: string, srcByte?: number) => void;
+/** A classified O-word control line: its keyword, its (opaque, normalized) id token, and any trailing
+ *  expression (an `if`/`while` condition or a `repeat` count). */
+export interface OwInfo {
+    keyword: string;
+    /** The id token verbatim-normalized: `100`, `<name>`, or a literal `[expr]` — matched, never evaluated. */
+    id: string;
+    expr: string;
+}
+/**
+ * Classify one raw line as an O-word control line, or `null` when it is not one. `null` covers every
+ * plain line (all FDM, all geometry/param lines) AND an `o<id>` whose trailing word is not a recognized
+ * keyword (e.g. `o5 g1 x10`) — those fall through to the normal lexer, so classification never hijacks
+ * ordinary code. The id is read as an opaque token (numeric / `<name>` / balanced `[expr]`) and is used
+ * only to pair an opener with its closer — it is deliberately NOT evaluated here.
+ */
+export declare function classifyOWord(rawLine: string): OwInfo | null;
+/** One buffered source line with its byte offset (for `srcByte` on any geometry it emits). */
+export interface FlowLine {
+    text: string;
+    offset: number;
+}
+/** The engine surface the interpreter drives — supplied by `createEngine` with its closures. */
+export interface FlowHost {
+    /** Execute one plain (non-control) source line through the normal engine path. */
+    processLine(text: string, offset: number): void;
+    /** True once a geometry limit (segments/buffer) has stopped emission — the interpreter then halts. */
+    stopped(): boolean;
+    /** Evaluate a control expression against the shared parameter store; `null` = malformed/non-finite. */
+    evalExpression(text: string, srcByte: number): number | null;
+    /** Push a subroutine call-frame scope with `args` bound to `#1`..`#30` (Phase 3). */
+    pushScope(args: readonly number[]): void;
+    /** Pop the current call-frame scope (Phase 3). */
+    popScope(): void;
+    warn: WarnFn;
+    maxProgramIterations: number;
+    /** Subroutine recursion depth cap (Phase 3); exceeding it discloses and skips the call. */
+    maxCallDepth: number;
+}
+export interface FlowOutcome {
+    /** True when execution was degraded (limit hit, unbalanced/unsupported O-word, malformed condition). */
+    degraded: boolean;
+}
+/** True once the built tree used any recognized control construct (drives the capability). */
+export declare function programUsesOWords(text: string): boolean;
+/** True when a single line is a recognized O-word control line (used by the streaming disclosure). */
+export declare function isOWordControlLine(line: string): boolean;
+/**
+ * Interpret a fully-buffered O-word program. Builds the block tree (tolerant of unbalanced O-words —
+ * disclosed, never thrown out), then executes it with bounded iteration. Returns whether execution was
+ * degraded so the caller can tier the `parametricProgram` capability.
+ */
+export declare function interpretOWordProgram(lines: readonly FlowLine[], host: FlowHost): FlowOutcome;
+//# sourceMappingURL=rs274-flow.d.ts.map

package/dist/rs274-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rs274-flow.d.ts","sourceRoot":"","sources":["../src/rs274-flow.ts"],"names":[],"mappings":"AAgCA,8EAA8E;AAC9E,eAAO,MAAM,eAAe;;;;;;;;;;CAUlB,CAAC;AAeX;4GAC4G;AAC5G,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAgBnD,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAE/E;kEACkE;AAClE,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,2GAA2G;IAC3G,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkD5D;AAED,8FAA8F;AAC9F,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gGAAgG;AAChG,MAAM,WAAW,QAAQ;IACvB,kFAAkF;IAClF,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,sGAAsG;IACtG,OAAO,IAAI,OAAO,CAAC;IACnB,uGAAuG;IACvG,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC7D,qFAAqF;IACrF,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACzC,kDAAkD;IAClD,QAAQ,IAAI,IAAI,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,EAAE,MAAM,CAAC;IAC7B,2FAA2F;IAC3F,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,wGAAwG;IACxG,QAAQ,EAAE,OAAO,CAAC;CACnB;AAoCD,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAUvD;AAED,sGAAsG;AACtG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AA2FD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CAmb7F"}