@chestnutlabs/gcode-dialects 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @chestnutlabs/gcode-dialects
+
+Slicer/firmware **dialect adapters** for the Chestnut Labs G-code Preview stack (design: DD-005).
+Dialect adapters *annotate* a parse — features, object boundaries, bed geometry, thumbnails,
+multi-tool metadata — and are forbidden from changing geometry (a geometry-invariance gate
+enforces it).
+
+Supported dialects: **PrusaSlicer, OrcaSlicer/Bambu Studio, Cura, Klipper, Marlin,
+RepRap-flavor** — see the evidence-dated
+[compatibility matrix](../../docs/compatibility/dialects-and-containers.md).
+
+Every annotation is capability-tagged (`known | inferred | approximated | unavailable`); consumers
+render what is known and disclose what is not.
+
+This package is bundled into the parser's default *batteries* worker — most applications never
+import it directly. Import it to build a **custom worker** with a chosen adapter subset, or to
+register your own adapter against the annotator contract.
+
+Part of [Chestnut Labs G-code Preview](../../README.md) · MIT

package/dist/annotate.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared annotation helpers for slicer adapters (DD-005 phase 3, issue #75).
+ *
+ * Comment markers arrive with a source-byte position but no segment index; the
+ * IR's byte-ordered sourceIndex resolves them to segment ranges in `finalize`
+ * (DD-005 §4.3: "annotation ranges are [segAtEvent, segBeforeNextEvent]").
+ */
+import type { MachineGeometry, Point2, ToolpathIR } from '@chestnutlabs/toolpath-core';
+import type { AnnotationSink } from './contracts.js';
+/** First segment whose producing command starts at or after `byte`. */
+export declare function segAtOrAfterByte(ir: ToolpathIR, byte: number): number;
+export interface RangeMarker {
+    srcByte: number;
+    value: number;
+}
+/**
+ * Apply byte-positioned markers as contiguous channel ranges: each marker
+ * covers [its first segment, the next marker's first segment - 1]. A marker
+ * value of 0 acts as a range terminator (back to unknown/none).
+ */
+export declare function applyMarkerRanges(ir: ToolpathIR, markers: RangeMarker[], write: (segStart: number, segEnd: number, value: number) => void): number;
+export interface SegMarker {
+    segIndex: number;
+    value: number;
+}
+/**
+ * Apply SEGMENT-indexed markers (CommandEvent.segIndex — exact, no byte
+ * resolution needed) as contiguous ranges; value 0 terminates (DD-005 phase 5).
+ */
+export declare function applySegmentMarkers(markers: SegMarker[], segmentCount: number, write: (segStart: number, segEnd: number, value: number) => void): number;
+/** Parse `key = value` / `key: value` slicer comment lines (Prusa tail, Orca header/config blocks). */
+export declare function parseKeyValue(comment: string): {
+    key: string;
+    value: string;
+} | null;
+/** Parse "0x0,250x0,250x210,0x210" bed/printable-area point lists. */
+export declare function parseAreaPoints(value: string): Point2[] | null;
+/** Points → MachineGeometry bed (axis-aligned quad becomes rect, else polygon). */
+export declare function bedFromPoints(points: Point2[], adapterId: string, evidence: string, heightMm: number | undefined, printerName: string | undefined, srcByte: number | undefined): MachineGeometry;
+/** Dependency-free base64 decode (thumbnail comments); returns null on invalid input. */
+export declare function decodeBase64(text: string): Uint8Array | null;
+/** Shared thumbnail-comment accumulator (`thumbnail begin WxH LEN` … base64 … `thumbnail end`). */
+export declare class ThumbnailCollector {
+    private readonly maxBytesPerThumbnail;
+    private active;
+    constructor(maxBytesPerThumbnail?: number);
+    /** True while inside a begin/end block — the adapter must route EVERY comment here. */
+    get isActive(): boolean;
+    /** Feed one comment line; emits to the sink when a bounded thumbnail completes. */
+    feed(comment: string, sink: AnnotationSink): void;
+}
+//# sourceMappingURL=annotate.d.ts.map

package/dist/annotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate.d.ts","sourceRoot":"","sources":["../src/annotate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAUrE;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,EAAE,EACtB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAC/D,MAAM,CAYR;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAAE,EACpB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAC/D,MAAM,CAYR;AAED,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAGpF;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAU9D;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,eAAe,CAejB;AASD,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAkB5D;AAED,mGAAmG;AACnG,qBAAa,kBAAkB;IAEjB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IADjD,OAAO,CAAC,MAAM,CAAgF;gBACjE,oBAAoB,SAAa;IAE9D,uFAAuF;IACvF,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,mFAAmF;IACnF,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI;CA8BlD"}

package/dist/annotate.js

@@ -0,0 +1,157 @@
+/** First segment whose producing command starts at or after `byte`. */
+export function segAtOrAfterByte(ir, byte) {
+    const offsets = ir.sourceIndex.byteOffsets;
+    let lo = 0;
+    let hi = offsets.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (offsets[mid] < byte)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo < offsets.length ? ir.sourceIndex.segmentIndices[lo] : ir.segments.count;
+}
+/**
+ * Apply byte-positioned markers as contiguous channel ranges: each marker
+ * covers [its first segment, the next marker's first segment - 1]. A marker
+ * value of 0 acts as a range terminator (back to unknown/none).
+ */
+export function applyMarkerRanges(ir, markers, write) {
+    let applied = 0;
+    for (let i = 0; i < markers.length; i++) {
+        if (markers[i].value === 0)
+            continue;
+        const start = segAtOrAfterByte(ir, markers[i].srcByte);
+        const end = (i + 1 < markers.length ? segAtOrAfterByte(ir, markers[i + 1].srcByte) : ir.segments.count) - 1;
+        if (end >= start) {
+            write(start, end, markers[i].value);
+            applied++;
+        }
+    }
+    return applied;
+}
+/**
+ * Apply SEGMENT-indexed markers (CommandEvent.segIndex — exact, no byte
+ * resolution needed) as contiguous ranges; value 0 terminates (DD-005 phase 5).
+ */
+export function applySegmentMarkers(markers, segmentCount, write) {
+    let applied = 0;
+    for (let i = 0; i < markers.length; i++) {
+        if (markers[i].value === 0)
+            continue;
+        const start = markers[i].segIndex;
+        const end = (i + 1 < markers.length ? markers[i + 1].segIndex : segmentCount) - 1;
+        if (end >= start && start < segmentCount) {
+            write(start, Math.min(end, segmentCount - 1), markers[i].value);
+            applied++;
+        }
+    }
+    return applied;
+}
+/** Parse `key = value` / `key: value` slicer comment lines (Prusa tail, Orca header/config blocks). */
+export function parseKeyValue(comment) {
+    const m = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*[:=]\s*(.*\S)\s*$/.exec(comment);
+    return m === null ? null : { key: m[1].toLowerCase(), value: m[2] };
+}
+/** Parse "0x0,250x0,250x210,0x210" bed/printable-area point lists. */
+export function parseAreaPoints(value) {
+    const parts = value.split(',');
+    if (parts.length < 3 || parts.length > 64)
+        return null;
+    const points = [];
+    for (const p of parts) {
+        const m = /^\s*(-?\d+(?:\.\d+)?)x(-?\d+(?:\.\d+)?)\s*$/.exec(p);
+        if (m === null)
+            return null;
+        points.push({ x: parseFloat(m[1]), y: parseFloat(m[2]) });
+    }
+    return points;
+}
+/** Points → MachineGeometry bed (axis-aligned quad becomes rect, else polygon). */
+export function bedFromPoints(points, adapterId, evidence, heightMm, printerName, srcByte) {
+    const xs = points.map((p) => p.x);
+    const ys = points.map((p) => p.y);
+    const min = { x: Math.min(...xs), y: Math.min(...ys) };
+    const max = { x: Math.max(...xs), y: Math.max(...ys) };
+    const rect = points.length === 4 && points.every((p) => (p.x === min.x || p.x === max.x) && (p.y === min.y || p.y === max.y));
+    return {
+        bed: rect ? { kind: 'rect', min, max } : { kind: 'polygon', points },
+        origin: { x: 0, y: 0 },
+        heightMm,
+        printerName,
+        confidence: 'inferred', // read from slicer COMMENTS, not machine config
+        source: { adapterId, evidence, srcByte }
+    };
+}
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const B64_LOOKUP = (() => {
+    const t = new Int8Array(128).fill(-1);
+    for (let i = 0; i < B64.length; i++)
+        t[B64.charCodeAt(i)] = i;
+    return t;
+})();
+/** Dependency-free base64 decode (thumbnail comments); returns null on invalid input. */
+export function decodeBase64(text) {
+    const clean = text.replace(/[\s=]+/g, '');
+    const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let acc = 0;
+    let bits = 0;
+    let o = 0;
+    for (let i = 0; i < clean.length; i++) {
+        const c = clean.charCodeAt(i);
+        const v = c < 128 ? B64_LOOKUP[c] : -1;
+        if (v === -1)
+            return null;
+        acc = (acc << 6) | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[o++] = (acc >> bits) & 0xff;
+        }
+    }
+    return out.subarray(0, o);
+}
+/** Shared thumbnail-comment accumulator (`thumbnail begin WxH LEN` … base64 … `thumbnail end`). */
+export class ThumbnailCollector {
+    maxBytesPerThumbnail;
+    active = null;
+    constructor(maxBytesPerThumbnail = 512 * 1024) {
+        this.maxBytesPerThumbnail = maxBytesPerThumbnail;
+    }
+    /** True while inside a begin/end block — the adapter must route EVERY comment here. */
+    get isActive() {
+        return this.active !== null;
+    }
+    /** Feed one comment line; emits to the sink when a bounded thumbnail completes. */
+    feed(comment, sink) {
+        const trimmed = comment.trim();
+        const begin = /^thumbnail(?:_JPG|_QOI)? begin (\d+)[x ](\d+) (\d+)/i.exec(trimmed);
+        if (begin !== null) {
+            const declared = parseInt(begin[3]);
+            this.active =
+                declared <= this.maxBytesPerThumbnail
+                    ? { width: parseInt(begin[1]), height: parseInt(begin[2]), b64: [], bytes: 0 }
+                    : null;
+            return;
+        }
+        if (/^thumbnail(?:_JPG|_QOI)? end/i.test(trimmed)) {
+            if (this.active !== null) {
+                const bytes = decodeBase64(this.active.b64.join(''));
+                if (bytes !== null && bytes.byteLength > 0) {
+                    sink.addThumbnail({ width: this.active.width, height: this.active.height, mime: 'image/png', bytes });
+                }
+            }
+            this.active = null;
+            return;
+        }
+        if (this.active !== null) {
+            this.active.bytes += trimmed.length;
+            if (this.active.bytes > (this.maxBytesPerThumbnail * 4) / 3 + 8) {
+                this.active = null; // lied about its size — drop, stay bounded
+                return;
+            }
+            this.active.b64.push(trimmed);
+        }
+    }
+}

package/dist/contracts.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Dialect adapter behavioral contracts (DD-005 §4.1/§4.3, as amended).
+ *
+ * Adapters are ANNOTATORS: through the AnnotationSink they may write the
+ * optional `feature`/`object` channels, result metadata, and capability
+ * upgrades — the sink exposes no way to touch positions, kinds, layers, or
+ * counts, and the geometry-invariance CI gate proves it stays that way.
+ *
+ * Data contracts (MachineGeometry, DialectMetadata, DialectDetection) live in
+ * @chestnutlabs/toolpath-core (see its metadata.ts for the rationale).
+ */
+import type { Confidence, DialectDetection, MachineGeometry, FilamentInfo, ThumbnailData, ToolpathIR } from '@chestnutlabs/toolpath-core';
+/** Read-only normalized command event — mirror of the parser's hook payload. */
+export interface CommandEvent {
+    gcode: string;
+    params: Readonly<Record<string, number>>;
+    rawLine: string;
+    srcByte: number;
+    segIndex: number;
+}
+export interface DetectInput {
+    /** First decoded window (≤ 64 KB). */
+    headText: string;
+    /** Last decoded window (≤ 16 KB); '' for non-seekable streams until finalize (§4.5). */
+    tailText: string;
+    /** Container metadata when the input came through gcode-containers (phase 2). */
+    containerMeta?: Record<string, string>;
+}
+export interface AnnotationSink {
+    /** Write a FeatureRole index for segments [segStart, segEnd] (bounds validated at apply). */
+    setFeature(segStart: number, segEnd: number, role: number): void;
+    /** `objectValue` is the 1-based object-channel value (DD-001: v indexes ir.objects[v-1]). */
+    setObject(segStart: number, segEnd: number, objectValue: number): void;
+    defineObject(objectValue: number, name: string): void;
+    setMachine(machine: MachineGeometry): void;
+    setFilament(info: FilamentInfo): void;
+    /** Enrich a tool's identity (material, '#RRGGBB' color) — merged into ir.tools (DD-005 phase 5). */
+    setToolInfo(tool: number, info: {
+        material?: string;
+        colorHex?: string;
+    }): void;
+    addThumbnail(thumb: ThumbnailData): void;
+    setRaw(key: string, value: string): void;
+    upgradeCapability(key: string, confidence: Confidence): void;
+    warn(code: string, message: string, srcByte?: number): void;
+}
+export interface DialectAdapter {
+    id: string;
+    displayName: string;
+    /** 'slicer' and 'firmware' adapters COMPOSE (amendment 1); one winner per kind. */
+    kind: 'slicer' | 'firmware' | 'generic';
+    detect(input: DetectInput): DialectDetection | null;
+    /** Per-adapter serializable configuration (validated by the adapter itself). */
+    onComment?(comment: string, srcByte: number, sink: AnnotationSink, config?: unknown): void;
+    onCommand?(event: CommandEvent, sink: AnnotationSink, config?: unknown): void;
+    finalize?(ir: ToolpathIR, sink: AnnotationSink, config?: unknown): void;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,aAAa,EACb,UAAU,EACX,MAAM,6BAA6B,CAAC;AAErC,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,6FAA6F;IAC7F,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,6FAA6F;IAC7F,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACvE,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACtD,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAC3C,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACtC,oGAAoG;IACpG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAChF,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IACzC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC7D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7D;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IACxC,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAAC;IACpD,gFAAgF;IAChF,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3F,SAAS,CAAC,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9E,QAAQ,CAAC,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACzE"}

package/dist/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/cura.d.ts

@@ -0,0 +1,3 @@
+import type { DialectAdapter } from './contracts.js';
+export declare function cura(): DialectAdapter;
+//# sourceMappingURL=cura.d.ts.map

package/dist/cura.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cura.d.ts","sourceRoot":"","sources":["../src/cura.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAiCrE,wBAAgB,IAAI,IAAI,cAAc,CAkCrC"}

package/dist/cura.js

@@ -0,0 +1,70 @@
+/**
+ * Cura dialect adapter (DD-005 phase 4, issue #76).
+ *
+ * Annotates `;TYPE:` feature roles (Cura's UPPERCASE vocabulary) and picks up
+ * the printer name where newer Cura versions expose it. Bed geometry is NOT
+ * derivable from standard Cura output (its settings tail encodes machine size
+ * inside a packed settings blob — out of v1 scope; matrix records `partial`).
+ */
+import { FeatureRole } from '@chestnutlabs/toolpath-core';
+import { applyMarkerRanges, parseKeyValue } from './annotate.js';
+/** Cura `;TYPE:` names → DD-001 FeatureRole. */
+const TYPE_MAP = {
+    'wall-outer': FeatureRole.ExternalPerimeter,
+    'wall-inner': FeatureRole.Perimeter,
+    skin: FeatureRole.SolidInfill,
+    fill: FeatureRole.Infill,
+    support: FeatureRole.Support,
+    'support-interface': FeatureRole.Support,
+    skirt: FeatureRole.Skirt,
+    raft: FeatureRole.Brim,
+    'prime-tower': FeatureRole.Custom,
+    bridge: FeatureRole.Bridge
+};
+const state = new WeakMap();
+function stateFor(sink) {
+    let s = state.get(sink);
+    if (s === undefined) {
+        s = { markers: [] };
+        state.set(sink, s);
+    }
+    return s;
+}
+export function cura() {
+    return {
+        id: 'cura',
+        displayName: 'Cura',
+        kind: 'slicer',
+        detect(input) {
+            const m = /Generated with (Cura_SteamEngine[^\n\r]*)/.exec(input.headText);
+            if (m !== null) {
+                return { dialectId: 'cura', kind: 'slicer', confidence: 'known', evidence: `header: ${m[1].trim()}` };
+            }
+            return null;
+        },
+        onComment(comment, srcByte, sink) {
+            const s = stateFor(sink);
+            const trimmed = comment.trim();
+            if (trimmed.startsWith('TYPE:')) {
+                const role = TYPE_MAP[trimmed.slice(5).trim().toLowerCase()];
+                s.markers.push({ srcByte, value: role ?? FeatureRole.Custom });
+                return;
+            }
+            if (trimmed.startsWith('TARGET_MACHINE.NAME:')) {
+                s.printerName = trimmed.slice('TARGET_MACHINE.NAME:'.length).trim();
+                return;
+            }
+            const kv = parseKeyValue(comment);
+            if (kv !== null && kv.key === 'target_machine')
+                s.printerName = kv.value;
+        },
+        finalize(ir, sink) {
+            const s = stateFor(sink);
+            const applied = applyMarkerRanges(ir, s.markers, (a, b, v) => sink.setFeature(a, b, v));
+            if (applied > 0)
+                sink.upgradeCapability('featureRoles', 'known');
+            if (s.printerName !== undefined)
+                sink.setRaw('printer_model', s.printerName);
+        }
+    };
+}

package/dist/firmware.d.ts

@@ -0,0 +1,5 @@
+import type { DialectAdapter } from './contracts.js';
+export declare function klipper(): DialectAdapter;
+export declare function marlin(): DialectAdapter;
+export declare function repRap(): DialectAdapter;
+//# sourceMappingURL=firmware.d.ts.map

package/dist/firmware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firmware.d.ts","sourceRoot":"","sources":["../src/firmware.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAqCrE,wBAAgB,OAAO,IAAI,cAAc,CAkCxC;AAED,wBAAgB,MAAM,IAAI,cAAc,CAyBvC;AAED,wBAAgB,MAAM,IAAI,cAAc,CAevC"}

package/dist/firmware.js

@@ -0,0 +1,109 @@
+import { applySegmentMarkers } from './annotate.js';
+const objState = new WeakMap();
+function objStateFor(sink) {
+    let s = objState.get(sink);
+    if (s === undefined) {
+        s = { markers: [], names: new Map() };
+        objState.set(sink, s);
+    }
+    return s;
+}
+function objectValueFor(s, name) {
+    let v = s.names.get(name);
+    if (v === undefined) {
+        v = s.names.size + 1;
+        s.names.set(name, v);
+    }
+    return v;
+}
+function finalizeObjects(ir, sink, s) {
+    const applied = applySegmentMarkers(s.markers, ir.segments.count, (a, b, v) => sink.setObject(a, b, v));
+    if (applied > 0) {
+        for (const [name, value] of s.names)
+            sink.defineObject(value, name);
+        sink.upgradeCapability('objects', 'known');
+    }
+}
+export function klipper() {
+    return {
+        id: 'klipper',
+        displayName: 'Klipper',
+        kind: 'firmware',
+        detect(input) {
+            const m = /(EXCLUDE_OBJECT_DEFINE|SET_VELOCITY_LIMIT|ACTIVATE_EXTRUDER|SDCARD_PRINT_FILE)/.exec(input.headText);
+            if (m !== null) {
+                return { dialectId: 'klipper', kind: 'firmware', confidence: 'known', evidence: `command: ${m[1]}` };
+            }
+            if (/gcode_flavor\s*=\s*klipper/i.test(input.tailText)) {
+                return { dialectId: 'klipper', kind: 'firmware', confidence: 'known', evidence: 'gcode_flavor = klipper' };
+            }
+            return null;
+        },
+        onCommand(event, sink) {
+            // Extended commands don't survive the inherited lexer — match the raw line.
+            const m = /^\s*EXCLUDE_OBJECT_(DEFINE|START|END)\b(.*)$/i.exec(event.rawLine);
+            if (m === null)
+                return;
+            const s = objStateFor(sink);
+            const name = /NAME=([^\s]+)/i.exec(m[2])?.[1];
+            const verb = m[1].toUpperCase();
+            if (verb === 'DEFINE') {
+                if (name !== undefined)
+                    objectValueFor(s, name); // registers identity/order
+            }
+            else if (verb === 'START') {
+                if (name !== undefined)
+                    s.markers.push({ segIndex: event.segIndex, value: objectValueFor(s, name) });
+            }
+            else {
+                s.markers.push({ segIndex: event.segIndex, value: 0 }); // END terminates
+            }
+        },
+        finalize(ir, sink) {
+            finalizeObjects(ir, sink, objStateFor(sink));
+        }
+    };
+}
+export function marlin() {
+    return {
+        id: 'marlin',
+        displayName: 'Marlin',
+        kind: 'firmware',
+        detect(input) {
+            if (/^;\s*FLAVOR\s*:\s*Marlin/im.test(input.headText)) {
+                return { dialectId: 'marlin', kind: 'firmware', confidence: 'known', evidence: ';FLAVOR:Marlin header' };
+            }
+            if (/gcode_flavor\s*=\s*marlin/i.test(input.tailText)) {
+                return { dialectId: 'marlin', kind: 'firmware', confidence: 'inferred', evidence: 'gcode_flavor = marlin' };
+            }
+            return null;
+        },
+        onCommand(event, sink) {
+            // M486 S<idx> starts object idx (S-1 = none); M486 carries no names.
+            if (event.gcode !== 'm486' || event.params.s === undefined)
+                return;
+            const s = objStateFor(sink);
+            const idx = event.params.s;
+            s.markers.push({ segIndex: event.segIndex, value: idx >= 0 ? objectValueFor(s, `object ${idx}`) : 0 });
+        },
+        finalize(ir, sink) {
+            finalizeObjects(ir, sink, objStateFor(sink));
+        }
+    };
+}
+export function repRap() {
+    return {
+        id: 'reprap',
+        displayName: 'RepRap-style',
+        kind: 'firmware',
+        detect(input) {
+            if (/^;\s*FLAVOR\s*:\s*RepRap/im.test(input.headText)) {
+                return { dialectId: 'reprap', kind: 'firmware', confidence: 'known', evidence: ';FLAVOR:RepRap header' };
+            }
+            if (/gcode_flavor\s*=\s*reprap/i.test(input.tailText)) {
+                return { dialectId: 'reprap', kind: 'firmware', confidence: 'inferred', evidence: 'gcode_flavor = reprap' };
+            }
+            return null;
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @chestnutlabs/gcode-dialects — dialect adapter contracts & registry (DD-005).
+ *
+ * Phase 1 (#73): behavioral contracts, buffered annotation sink, and the
+ * composition runner. Built-in vendor adapters arrive in phases 3–5.
+ * Depends only on @chestnutlabs/toolpath-core; the parser consumes the runner
+ * through its own structural DialectRunnerFactory type (worker entries compose
+ * the two — DD-002 §5 boundaries).
+ */
+export type { DialectAdapter, DetectInput, AnnotationSink, CommandEvent } from './contracts.js';
+export { createDialectRunner } from './registry.js';
+export type { DialectRunnerFactory, DialectRun, DialectRunInput, DialectRunResult } from './registry.js';
+export { BufferedAnnotationSink } from './sink.js';
+export { prusaSlicer } from './prusaslicer.js';
+export { orcaBambu } from './orca-bambu.js';
+export { cura } from './cura.js';
+export { klipper, marlin, repRap } from './firmware.js';
+export { segAtOrAfterByte, applyMarkerRanges, parseKeyValue, parseAreaPoints, bedFromPoints, decodeBase64, ThumbnailCollector } from './annotate.js';
+export type { RangeMarker } from './annotate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACzG,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,aAAa,EACb,YAAY,EACZ,kBAAkB,EACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createDialectRunner } from './registry.js';
+export { BufferedAnnotationSink } from './sink.js';
+export { prusaSlicer } from './prusaslicer.js';
+export { orcaBambu } from './orca-bambu.js';
+export { cura } from './cura.js';
+export { klipper, marlin, repRap } from './firmware.js';
+export { segAtOrAfterByte, applyMarkerRanges, parseKeyValue, parseAreaPoints, bedFromPoints, decodeBase64, ThumbnailCollector } from './annotate.js';

package/dist/orca-bambu.d.ts

@@ -0,0 +1,3 @@
+import type { DialectAdapter } from './contracts.js';
+export declare function orcaBambu(): DialectAdapter;
+//# sourceMappingURL=orca-bambu.d.ts.map

package/dist/orca-bambu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orca-bambu.d.ts","sourceRoot":"","sources":["../src/orca-bambu.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAuDrE,wBAAgB,SAAS,IAAI,cAAc,CA8F1C"}

package/dist/orca-bambu.js

@@ -0,0 +1,138 @@
+/**
+ * OrcaSlicer / Bambu Studio dialect adapter (DD-005 phase 3, issue #75).
+ *
+ * Annotates: `; FEATURE:` roles (→ `featureRoles: 'known'`), Bambu object
+ * start/stop comments (→ `object` channel + `objects: 'known'`), bed geometry
+ * from `printable_area` config comments (bare .gcode files — inside a
+ * `.gcode.3mf` the container's machine config already provides `known`
+ * geometry and outranks this), and printer identity. Detection also accepts
+ * container metadata as evidence (DD-005 §4.1 DetectInput.containerMeta).
+ */
+import { FeatureRole } from '@chestnutlabs/toolpath-core';
+import { ThumbnailCollector, applyMarkerRanges, bedFromPoints, parseAreaPoints, parseKeyValue } from './annotate.js';
+/** Orca/Bambu `; FEATURE:` names → DD-001 FeatureRole. */
+const FEATURE_MAP = {
+    'inner wall': FeatureRole.Perimeter,
+    'outer wall': FeatureRole.ExternalPerimeter,
+    'overhang wall': FeatureRole.Perimeter,
+    'sparse infill': FeatureRole.Infill,
+    'internal solid infill': FeatureRole.SolidInfill,
+    'top surface': FeatureRole.SolidInfill,
+    'bottom surface': FeatureRole.SolidInfill,
+    ironing: FeatureRole.SolidInfill,
+    bridge: FeatureRole.Bridge,
+    support: FeatureRole.Support,
+    'support interface': FeatureRole.Support,
+    'support transition': FeatureRole.Support,
+    skirt: FeatureRole.Skirt,
+    brim: FeatureRole.Brim,
+    'prime tower': FeatureRole.Custom,
+    'gap infill': FeatureRole.Infill,
+    custom: FeatureRole.Custom
+};
+const state = new WeakMap();
+function stateFor(sink) {
+    let s = state.get(sink);
+    if (s === undefined) {
+        s = { features: [], objects: [], objectNames: new Map(), bedPoints: null, thumbs: new ThumbnailCollector() };
+        state.set(sink, s);
+    }
+    return s;
+}
+export function orcaBambu() {
+    return {
+        id: 'orca-bambu',
+        displayName: 'OrcaSlicer / Bambu Studio',
+        kind: 'slicer',
+        detect(input) {
+            const m = /(BambuStudio[^\n\r]*|generated by OrcaSlicer[^\n\r]*)/.exec(input.headText);
+            if (m !== null) {
+                return { dialectId: 'orca-bambu', kind: 'slicer', confidence: 'known', evidence: `header: ${m[1].trim()}` };
+            }
+            if (input.containerMeta !== undefined && input.containerMeta['printer_model'] !== undefined) {
+                return {
+                    dialectId: 'orca-bambu',
+                    kind: 'slicer',
+                    confidence: 'inferred',
+                    evidence: `container metadata: printer_model=${input.containerMeta['printer_model']}`
+                };
+            }
+            return null;
+        },
+        onComment(comment, srcByte, sink) {
+            const s = stateFor(sink);
+            const trimmed = comment.trim();
+            if (trimmed.startsWith('FEATURE:')) {
+                const role = FEATURE_MAP[trimmed.slice(8).trim().toLowerCase()];
+                s.features.push({ srcByte, value: role ?? FeatureRole.Custom });
+                return;
+            }
+            const start = /^start printing object,?\s*(?:unique\s+)?id:?\s*(\d+)(?:\s+name:\s*(.+))?/i.exec(trimmed);
+            if (start !== null) {
+                const value = parseInt(start[1]) + 1; // object channel is 1-based (0 = none)
+                s.objects.push({ srcByte, value });
+                if (start[2] !== undefined)
+                    s.objectNames.set(value, start[2].trim());
+                return;
+            }
+            if (/^stop printing object/i.test(trimmed)) {
+                s.objects.push({ srcByte, value: 0 }); // range terminator
+                return;
+            }
+            if (s.thumbs.isActive || trimmed.toLowerCase().startsWith('thumbnail')) {
+                s.thumbs.feed(comment, sink);
+                return;
+            }
+            const kv = parseKeyValue(comment);
+            if (kv === null)
+                return;
+            if (kv.key === 'printable_area') {
+                s.bedPoints = kv.value;
+                s.bedSrcByte = srcByte;
+            }
+            else if (kv.key === 'printable_height') {
+                const h = parseFloat(kv.value);
+                if (Number.isFinite(h))
+                    s.heightMm = h;
+            }
+            else if (kv.key === 'printer_model') {
+                s.printerModel = kv.value;
+            }
+            else if (kv.key === 'filament_type') {
+                s.filamentTypes = kv.value.split(';').map((v) => v.trim());
+            }
+            else if (kv.key === 'filament_colour') {
+                s.filamentColours = kv.value.split(';').map((v) => v.trim());
+            }
+        },
+        finalize(ir, sink) {
+            const s = stateFor(sink);
+            const features = applyMarkerRanges(ir, s.features, (a, b, v) => sink.setFeature(a, b, v));
+            if (features > 0)
+                sink.upgradeCapability('featureRoles', 'known');
+            const objects = applyMarkerRanges(ir, s.objects, (a, b, v) => sink.setObject(a, b, v));
+            if (objects > 0) {
+                for (const [value, name] of s.objectNames)
+                    sink.defineObject(value, name);
+                sink.upgradeCapability('objects', 'known');
+            }
+            if (s.bedPoints !== null) {
+                const points = parseAreaPoints(s.bedPoints);
+                if (points !== null) {
+                    sink.setMachine(bedFromPoints(points, 'orca-bambu', '; printable_area config comment', s.heightMm, s.printerModel, s.bedSrcByte));
+                }
+                else {
+                    sink.warn('dialect-bed-unparsed', 'printable_area comment present but unparseable');
+                }
+            }
+            if (s.printerModel !== undefined)
+                sink.setRaw('printer_model', s.printerModel);
+            // Multi-tool/AMS metadata (phase 5): filament slots enrich ir.tools.
+            const slots = Math.max(s.filamentTypes?.length ?? 0, s.filamentColours?.length ?? 0);
+            for (let i = 0; i < Math.min(slots, 64); i++) {
+                sink.setFilament({ slot: i, type: s.filamentTypes?.[i], color: s.filamentColours?.[i] });
+                sink.setToolInfo(i, { material: s.filamentTypes?.[i], colorHex: s.filamentColours?.[i] });
+            }
+        }
+    };
+}

package/dist/prusaslicer.d.ts

@@ -0,0 +1,3 @@
+import type { DialectAdapter } from './contracts.js';
+export declare function prusaSlicer(): DialectAdapter;
+//# sourceMappingURL=prusaslicer.d.ts.map

package/dist/prusaslicer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prusaslicer.d.ts","sourceRoot":"","sources":["../src/prusaslicer.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAiDrE,wBAAgB,WAAW,IAAI,cAAc,CA+D5C"}

package/dist/prusaslicer.js

@@ -0,0 +1,99 @@
+/**
+ * PrusaSlicer dialect adapter (DD-005 phase 3, issue #75).
+ *
+ * Annotates: `;TYPE:` feature roles (→ `featureRoles: 'known'`), bed geometry
+ * from the settings-block comments (`bed_shape`, `max_print_height`,
+ * `printer_model` — confidence `inferred`, provenance recorded), and bounded
+ * `; thumbnail begin/end` PNG thumbnails. Geometry is untouchable by contract.
+ */
+import { FeatureRole } from '@chestnutlabs/toolpath-core';
+import { ThumbnailCollector, applyMarkerRanges, bedFromPoints, parseAreaPoints, parseKeyValue } from './annotate.js';
+/** Prusa `;TYPE:` names → DD-001 FeatureRole (unknown names → Custom, honestly generic). */
+const TYPE_MAP = {
+    perimeter: FeatureRole.Perimeter,
+    'external perimeter': FeatureRole.ExternalPerimeter,
+    'overhang perimeter': FeatureRole.Perimeter,
+    'internal infill': FeatureRole.Infill,
+    'solid infill': FeatureRole.SolidInfill,
+    'top solid infill': FeatureRole.SolidInfill,
+    'bridge infill': FeatureRole.Bridge,
+    'internal bridge infill': FeatureRole.Bridge,
+    'support material': FeatureRole.Support,
+    'support material interface': FeatureRole.Support,
+    'skirt/brim': FeatureRole.Skirt,
+    skirt: FeatureRole.Skirt,
+    brim: FeatureRole.Brim,
+    'wipe tower': FeatureRole.Custom,
+    custom: FeatureRole.Custom
+};
+const state = new WeakMap();
+function stateFor(sink) {
+    let s = state.get(sink);
+    if (s === undefined) {
+        s = { markers: [], bedPoints: null, thumbs: new ThumbnailCollector() };
+        state.set(sink, s);
+    }
+    return s;
+}
+export function prusaSlicer() {
+    return {
+        id: 'prusaslicer',
+        displayName: 'PrusaSlicer',
+        kind: 'slicer',
+        detect(input) {
+            const m = /generated by (PrusaSlicer[^\n\r]*)/.exec(input.headText);
+            if (m !== null) {
+                return { dialectId: 'prusaslicer', kind: 'slicer', confidence: 'known', evidence: `header: ${m[1].trim()}` };
+            }
+            // Settings live at the tail; a tail-only match still identifies the file.
+            if (/;\s*generated by PrusaSlicer/.test(input.tailText) || /\n;\s*bed_shape\s*=/.test(input.tailText)) {
+                return { dialectId: 'prusaslicer', kind: 'slicer', confidence: 'inferred', evidence: 'settings block (tail)' };
+            }
+            return null;
+        },
+        onComment(comment, srcByte, sink) {
+            const s = stateFor(sink);
+            if (comment.startsWith('TYPE:')) {
+                const role = TYPE_MAP[comment.slice(5).trim().toLowerCase()];
+                s.markers.push({ srcByte, value: role ?? FeatureRole.Custom });
+                return;
+            }
+            if (s.thumbs.isActive || comment.trimStart().toLowerCase().startsWith('thumbnail')) {
+                s.thumbs.feed(comment, sink);
+                return;
+            }
+            const kv = parseKeyValue(comment);
+            if (kv === null)
+                return;
+            if (kv.key === 'bed_shape') {
+                s.bedPoints = kv.value;
+                s.bedSrcByte = srcByte;
+            }
+            else if (kv.key === 'max_print_height') {
+                const h = parseFloat(kv.value);
+                if (Number.isFinite(h))
+                    s.heightMm = h;
+            }
+            else if (kv.key === 'printer_model') {
+                s.printerModel = kv.value;
+            }
+        },
+        finalize(ir, sink) {
+            const s = stateFor(sink);
+            const applied = applyMarkerRanges(ir, s.markers, (a, b, v) => sink.setFeature(a, b, v));
+            if (applied > 0)
+                sink.upgradeCapability('featureRoles', 'known');
+            if (s.bedPoints !== null) {
+                const points = parseAreaPoints(s.bedPoints);
+                if (points !== null) {
+                    sink.setMachine(bedFromPoints(points, 'prusaslicer', '; bed_shape settings comment', s.heightMm, s.printerModel, s.bedSrcByte));
+                }
+                else {
+                    sink.warn('dialect-bed-unparsed', 'bed_shape comment present but unparseable');
+                }
+            }
+            if (s.printerModel !== undefined)
+                sink.setRaw('printer_model', s.printerModel);
+        }
+    };
+}

package/dist/registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Dialect registry & run composition (DD-005 §4.1/§4.5, as amended).
+ *
+ * Explicit, tree-shakeable: `createDialectRunner(adapters)` — no global
+ * side-effect registry. The returned factory matches the parser's structural
+ * `DialectRunnerFactory` shape (the parser never imports this package;
+ * worker entries compose the two).
+ *
+ * Composition (amendment 1): detection picks at most ONE adapter per `kind`
+ * (highest confidence wins; ties select none for that kind — never a guess),
+ * and all selected adapters run together. Adapter exceptions are contained:
+ * a throwing adapter is disabled for the run with an `adapter-failed` warning.
+ */
+import type { DialectDetection, DialectMetadata, ToolpathIR, Warning } from '@chestnutlabs/toolpath-core';
+import type { CommandEvent, DialectAdapter } from './contracts.js';
+export interface DialectRunInput {
+    /** 'auto' runs detection over all registered adapters; an array restricts by id. */
+    selection: 'auto' | string[];
+    config?: Record<string, unknown>;
+    headText: string;
+    tailText: string;
+    containerMeta?: Record<string, string>;
+}
+export interface DialectRunResult {
+    metadata?: DialectMetadata;
+    warnings: Warning[];
+}
+export interface DialectRun {
+    detections: DialectDetection[];
+    onComment: (text: string, srcByte: number) => void;
+    onCommand: (event: CommandEvent) => void;
+    finalize(ir: ToolpathIR): DialectRunResult;
+}
+export interface DialectRunnerFactory {
+    adapterIds: string[];
+    createRun(input: DialectRunInput): DialectRun | null;
+}
+export declare function createDialectRunner(adapters: DialectAdapter[]): DialectRunnerFactory;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAe,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAKhF,MAAM,WAAW,eAAe;IAC9B,oFAAoF;IACpF,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,gBAAgB,CAAC;CAC5C;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,UAAU,GAAG,IAAI,CAAC;CACtD;AAUD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,oBAAoB,CAsFpF"}

package/dist/registry.js

@@ -0,0 +1,87 @@
+import { BufferedAnnotationSink } from './sink.js';
+const CONFIDENCE_RANK = { known: 3, inferred: 2, approximated: 1, unavailable: 0 };
+export function createDialectRunner(adapters) {
+    return {
+        adapterIds: adapters.map((a) => a.id),
+        createRun(input) {
+            const pool = input.selection === 'auto' ? adapters : adapters.filter((a) => input.selection.includes(a.id));
+            const detect = {
+                headText: input.headText,
+                tailText: input.tailText,
+                containerMeta: input.containerMeta
+            };
+            // Detection: best confidence per kind; ambiguous ties select none for that kind.
+            const byKind = new Map();
+            for (const adapter of pool) {
+                let detection = null;
+                try {
+                    detection = adapter.detect(detect);
+                }
+                catch {
+                    detection = null;
+                }
+                if (detection === null)
+                    continue;
+                const list = byKind.get(adapter.kind) ?? [];
+                list.push({ adapter, detection });
+                byKind.set(adapter.kind, list);
+            }
+            const active = [];
+            for (const list of byKind.values()) {
+                list.sort((a, b) => CONFIDENCE_RANK[b.detection.confidence] - CONFIDENCE_RANK[a.detection.confidence]);
+                const best = list[0];
+                const tied = list.length > 1 &&
+                    CONFIDENCE_RANK[list[1].detection.confidence] === CONFIDENCE_RANK[best.detection.confidence];
+                if (tied)
+                    continue; // never a guess presented as a decision
+                active.push({
+                    adapter: best.adapter,
+                    detection: best.detection,
+                    sink: new BufferedAnnotationSink(best.adapter.id),
+                    config: input.config?.[best.adapter.id],
+                    failed: false
+                });
+            }
+            if (active.length === 0)
+                return null;
+            const contain = (a, fn) => {
+                if (a.failed)
+                    return;
+                try {
+                    fn();
+                }
+                catch (err) {
+                    a.failed = true;
+                    a.sink.warn('adapter-failed', `adapter '${a.adapter.id}' failed: ${err instanceof Error ? err.message : err}`);
+                }
+            };
+            return {
+                detections: active.map((a) => a.detection),
+                onComment: (text, srcByte) => {
+                    for (const a of active) {
+                        if (a.adapter.onComment)
+                            contain(a, () => a.adapter.onComment?.(text, srcByte, a.sink, a.config));
+                    }
+                },
+                onCommand: (event) => {
+                    for (const a of active) {
+                        if (a.adapter.onCommand)
+                            contain(a, () => a.adapter.onCommand?.(event, a.sink, a.config));
+                    }
+                },
+                finalize(ir) {
+                    const metadata = { dialects: active.map((a) => a.detection) };
+                    const conflicts = [];
+                    for (const a of active) {
+                        contain(a, () => a.adapter.finalize?.(ir, a.sink, a.config));
+                        a.sink.apply(ir, metadata, (code, message) => conflicts.push({ code, message, severity: 'warn', count: 1 }));
+                    }
+                    for (const w of conflicts)
+                        ir.header.warnings.push(w);
+                    ir.header.dialects.push(...active.map((a) => ({ id: a.detection.dialectId, confidence: a.detection.confidence })));
+                    return { metadata, warnings: conflicts };
+                }
+            };
+        }
+    };
+}

package/dist/sink.d.ts

@@ -0,0 +1,47 @@
+/**
+ * AnnotationSink implementation (DD-005 §4.1).
+ *
+ * Writes are BUFFERED as ops during the parse (the IR's final channels don't
+ * exist until `finish()`), then applied to the finished IR in one validated
+ * pass. Bounds are clamped, budgets enforced, and the sink physically cannot
+ * reach geometry — it only ever touches `feature`, `object`, header
+ * capabilities/warnings, and the metadata object beside the IR.
+ */
+import type { Confidence, DialectMetadata, FilamentInfo, MachineGeometry, ThumbnailData, ToolpathIR } from '@chestnutlabs/toolpath-core';
+import type { AnnotationSink } from './contracts.js';
+export declare class BufferedAnnotationSink implements AnnotationSink {
+    private readonly adapterId;
+    private ops;
+    private objects;
+    private machine;
+    private filaments;
+    private toolInfos;
+    private thumbnails;
+    private raw;
+    private capabilities;
+    private warnings;
+    private overflow;
+    constructor(adapterId: string);
+    private pushOp;
+    setFeature(segStart: number, segEnd: number, role: number): void;
+    setObject(segStart: number, segEnd: number, objectId: number): void;
+    defineObject(id: number, name: string): void;
+    setMachine(machine: MachineGeometry): void;
+    setFilament(info: FilamentInfo): void;
+    setToolInfo(tool: number, info: {
+        material?: string;
+        colorHex?: string;
+    }): void;
+    addThumbnail(thumb: ThumbnailData): void;
+    setRaw(key: string, value: string): void;
+    upgradeCapability(key: string, confidence: Confidence): void;
+    warn(code: string, message: string, srcByte?: number): void;
+    /**
+     * Apply buffered annotations to the finished IR (channels + header) and merge
+     * this adapter's contribution into the shared metadata object. Range ops are
+     * clamped to the real segment count — a lying adapter cannot write outside
+     * the buffers, and geometry channels are unreachable by construction.
+     */
+    apply(ir: ToolpathIR, metadata: DialectMetadata, conflictWarn: (code: string, message: string) => void): void;
+}
+//# sourceMappingURL=sink.d.ts.map

package/dist/sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../src/sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,YAAY,EACZ,eAAe,EACf,aAAa,EACb,UAAU,EAEX,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAWrD,qBAAa,sBAAuB,YAAW,cAAc;IAY/C,OAAO,CAAC,QAAQ,CAAC,SAAS;IAXtC,OAAO,CAAC,GAAG,CAAiB;IAC5B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,SAAS,CAA+D;IAChF,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,GAAG,CAA6B;IACxC,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAS;gBAEI,SAAS,EAAE,MAAM;IAE9C,OAAO,CAAC,MAAM;IAYd,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIhE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAInE,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5C,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAI1C,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAI/E,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAIxC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIxC,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IAI5D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAS3D;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;CAwD9G"}

package/dist/sink.js

@@ -0,0 +1,140 @@
+const MAX_RANGE_OPS = 1_000_000;
+const MAX_OBJECTS = 10_000;
+const MAX_RAW_ENTRIES = 512;
+const MAX_RAW_VALUE = 4_096;
+const MAX_WARNINGS = 100;
+const MAX_THUMBNAILS = 8;
+export class BufferedAnnotationSink {
+    adapterId;
+    ops = [];
+    objects = new Map();
+    machine = null;
+    filaments = [];
+    toolInfos = new Map();
+    thumbnails = [];
+    raw = new Map();
+    capabilities = new Map();
+    warnings = [];
+    overflow = false;
+    constructor(adapterId) {
+        this.adapterId = adapterId;
+    }
+    pushOp(op) {
+        if (this.ops.length >= MAX_RANGE_OPS) {
+            if (!this.overflow) {
+                this.overflow = true;
+                this.warn('dialect-annotation-truncated', `adapter '${this.adapterId}' exceeded the annotation op budget`);
+            }
+            return;
+        }
+        if (op.end < op.start || op.start < 0)
+            return;
+        this.ops.push(op);
+    }
+    setFeature(segStart, segEnd, role) {
+        this.pushOp({ channel: 'feature', start: segStart, end: segEnd, value: role & 0xff });
+    }
+    setObject(segStart, segEnd, objectId) {
+        this.pushOp({ channel: 'object', start: segStart, end: segEnd, value: objectId >>> 0 });
+    }
+    defineObject(id, name) {
+        if (this.objects.size < MAX_OBJECTS)
+            this.objects.set(id, name.slice(0, 256));
+    }
+    setMachine(machine) {
+        this.machine = machine;
+    }
+    setFilament(info) {
+        if (this.filaments.length < 64)
+            this.filaments.push(info);
+    }
+    setToolInfo(tool, info) {
+        if (this.toolInfos.size < 64)
+            this.toolInfos.set(tool, info);
+    }
+    addThumbnail(thumb) {
+        if (this.thumbnails.length < MAX_THUMBNAILS)
+            this.thumbnails.push(thumb);
+    }
+    setRaw(key, value) {
+        if (this.raw.size < MAX_RAW_ENTRIES)
+            this.raw.set(key.slice(0, 128), value.slice(0, MAX_RAW_VALUE));
+    }
+    upgradeCapability(key, confidence) {
+        this.capabilities.set(key, confidence);
+    }
+    warn(code, message, srcByte) {
+        const existing = this.warnings.find((w) => w.code === code);
+        if (existing) {
+            existing.count = (existing.count ?? 1) + 1;
+        }
+        else if (this.warnings.length < MAX_WARNINGS) {
+            this.warnings.push({ code, message, severity: 'warn', srcByte, count: 1 });
+        }
+    }
+    /**
+     * Apply buffered annotations to the finished IR (channels + header) and merge
+     * this adapter's contribution into the shared metadata object. Range ops are
+     * clamped to the real segment count — a lying adapter cannot write outside
+     * the buffers, and geometry channels are unreachable by construction.
+     */
+    apply(ir, metadata, conflictWarn) {
+        const count = ir.segments.count;
+        const touched = { feature: false, object: false };
+        for (const op of this.ops) {
+            const start = Math.min(op.start, count);
+            const end = Math.min(op.end + 1, count);
+            if (end <= start)
+                continue;
+            ir.segments[op.channel].fill(op.value, start, end);
+            touched[op.channel] = true;
+        }
+        // Object channel semantics (DD-001): value v > 0 indexes ir.objects[v-1].
+        for (const [channelValue, name] of [...this.objects.entries()].sort((a, b) => a[0] - b[0])) {
+            if (channelValue < 1)
+                continue;
+            while (ir.objects.length < channelValue) {
+                ir.objects.push({ id: String(ir.objects.length + 1) });
+            }
+            ir.objects[channelValue - 1] = { id: String(channelValue), name };
+        }
+        for (const [toolId, info] of this.toolInfos) {
+            let entry = ir.tools.find((t) => t.id === toolId);
+            if (entry === undefined) {
+                entry = { id: toolId };
+                ir.tools.push(entry);
+                ir.tools.sort((a, b) => a.id - b.id);
+            }
+            if (info.material !== undefined)
+                entry.material = info.material;
+            if (info.colorHex !== undefined) {
+                const m = /^#?([0-9a-f]{6})$/i.exec(info.colorHex.trim());
+                if (m !== null) {
+                    const v = parseInt(m[1], 16);
+                    entry.color = { r: ((v >> 16) & 0xff) / 255, g: ((v >> 8) & 0xff) / 255, b: (v & 0xff) / 255, a: 1 };
+                }
+            }
+        }
+        for (const [key, confidence] of this.capabilities) {
+            ir.header.capabilities[key] = confidence;
+        }
+        for (const w of this.warnings) {
+            ir.header.warnings.push(w);
+        }
+        if (this.machine !== null) {
+            if (metadata.machine !== undefined) {
+                conflictWarn('dialect-conflict', `adapter '${this.adapterId}' overwrote machine geometry`);
+            }
+            metadata.machine = this.machine;
+        }
+        if (this.filaments.length > 0) {
+            metadata.filaments = [...(metadata.filaments ?? []), ...this.filaments];
+        }
+        if (this.thumbnails.length > 0) {
+            metadata.thumbnails = [...(metadata.thumbnails ?? []), ...this.thumbnails];
+        }
+        if (this.raw.size > 0) {
+            metadata.raw = { ...(metadata.raw ?? {}), ...Object.fromEntries(this.raw) };
+        }
+    }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@chestnutlabs/gcode-dialects",
+  "version": "0.1.0",
+  "description": "Slicer/firmware dialect adapters for ToolpathIR annotation (DD-005). Adapters annotate metadata and optional channels \u2014 they can never alter geometry.",
+  "keywords": [
+    "gcode",
+    "3d-printing",
+    "toolpath",
+    "cnc",
+    "chestnutlabs",
+    "slicer",
+    "prusaslicer",
+    "cura",
+    "bambu",
+    "klipper",
+    "marlin",
+    "reprap"
+  ],
+  "author": "Chestnut Labs",
+  "homepage": "https://github.com/ChestnutLabs/gcode-preview#readme",
+  "bugs": "https://github.com/ChestnutLabs/gcode-preview/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ChestnutLabs/gcode-preview.git",
+    "directory": "packages/gcode-dialects"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@chestnutlabs/toolpath-core": "0.1.0"
+  }
+}