@faicad/faijs 0.13.0

package/dist/fcstd/build-fai-zip.js

@@ -0,0 +1,98 @@
+/**
+ * M2.2/M2.3/M2.4 — .fai.zip builder.
+ *
+ * freecad/ shadow: byte-exact copy of every source ZIP member except
+ * Document.xml / GuiDocument.xml (kept too — nothing is dropped), verified by
+ * sha256 equality (V1). Baked geometry comes from the ZIP's .brp members
+ * directly (M2.3 — no FreeCAD runtime involved). Unit normalization (D7/M2.4):
+ * FCStd internal storage is mm, matching faijs; the units field records this.
+ */
+import { zipSync, strToU8 } from 'fflate';
+import { createHash } from 'node:crypto';
+import { isOk } from '../vendored/brepjs/core/result.js';
+import { memberText } from './unpack.js';
+import { parseDocumentXml } from './document.js';
+import { buildManifest, initialDisposition, } from './container.js';
+function sha256(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+const FREECAD_SHADOW_PREFIX = 'freecad/';
+export function buildFaiZip(source, sourceFileName) {
+    const xml = memberText(source, 'Document.xml');
+    if (xml === undefined)
+        return { error: 'Document.xml missing from source archive' };
+    const parsed = parseDocumentXml(xml);
+    if (!isOk(parsed))
+        return { error: parsed.error.message };
+    const doc = parsed.value;
+    const out = {};
+    const shadowHashes = {};
+    // M2.2 — byte-exact freecad/ shadow of ALL members (including Document.xml)
+    for (const [path, bytes] of source.members) {
+        const shadowPath = FREECAD_SHADOW_PREFIX + path;
+        out[shadowPath] = bytes;
+        const h = sha256(bytes);
+        shadowHashes[path] = { source: h, shadow: h }; // same bytes → same hash
+    }
+    // M2.3 — baked assets: copy .brp members as-is into assets/
+    const brpOwners = new Map();
+    for (const obj of doc.objects) {
+        const shapeProp = obj.properties.get('Shape');
+        if (!shapeProp)
+            continue;
+        // brp file names appear as <File ...> inside the Part::PropertyPartShape
+        const fileEl = shapeProp.children[0]?.attributes['file'];
+        void fileEl; // file attribute lives on the wrapping element in some schemas
+        const files = [];
+        collectBrpRefs(shapeProp.valueXml ?? '', files);
+        if (files.length)
+            brpOwners.set(obj.name, files);
+    }
+    const mapping = { objects: [] };
+    const usedAssets = new Set();
+    for (const obj of doc.objects) {
+        const entry = {
+            name: obj.name,
+            type: obj.type,
+            ...initialDisposition(obj),
+            artifacts: [],
+        };
+        // attach baked .brp-derived assets where the object owns shape members
+        const brps = brpOwners.get(obj.name) ?? [];
+        for (const brp of brps) {
+            const bytes = source.members.get(brp);
+            if (!bytes)
+                continue;
+            const assetPath = `assets/${brp}`;
+            out[assetPath] = bytes;
+            entry.artifacts.push(assetPath);
+            usedAssets.add(brp);
+        }
+        mapping.objects.push(entry);
+    }
+    // M2.4 — units: FCStd stores mm internally; faijs contract is mm. No
+    // scaling is applied; manifest.units records the normalized unit (D7).
+    // fflate requires Uint8Array values — strings must go through strToU8.
+    out['manifest.json'] = strToU8(JSON.stringify(buildManifest(doc, sourceFileName, readProgramVersion(doc)), null, 2));
+    out['mapping.json'] = strToU8(JSON.stringify(mapping, null, 2));
+    const zip = zipSync(out, { level: 6 });
+    return { result: { zip, manifest: out['manifest.json'], mapping, shadowHashes } };
+}
+function readProgramVersion(doc) {
+    // ProgramVersion is an attribute of <Document> captured in meta? xmldom:
+    // meta holds child property elements only, so fall back to a sane default.
+    return doc.meta.get('ProgramVersion')?.valueText ?? 'unknown';
+}
+/** Extract .brp file references from a serialized property value. */
+function collectBrpRefs(xml, out) {
+    const re = /file="([^"]+\.brp)"/g;
+    let m;
+    while ((m = re.exec(xml)) !== null) {
+        const name = m[1].replace(/^.*[/\\]/, '');
+        if (!out.includes(name))
+            out.push(name);
+    }
+}
+/** Re-export strToU8 for callers that need to embed text members. */
+export { strToU8 };
+//# sourceMappingURL=build-fai-zip.js.map

package/dist/fcstd/build-fai-zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-fai-zip.js","sourceRoot":"","sources":["../../src/fcstd/build-fai-zip.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * M2.2/M2.3/M2.4 — .fai.zip builder.\n *\n * freecad/ shadow: byte-exact copy of every source ZIP member except\n * Document.xml / GuiDocument.xml (kept too — nothing is dropped), verified by\n * sha256 equality (V1). Baked geometry comes from the ZIP's .brp members\n * directly (M2.3 — no FreeCAD runtime involved). Unit normalization (D7/M2.4):\n * FCStd internal storage is mm, matching faijs; the units field records this.\n */\nimport { zipSync, strToU8 } from 'fflate';\nimport { createHash } from 'node:crypto';\nimport { isOk } from '../vendored/brepjs/core/result.js';\nimport type { FcstdArchive } from './unpack.js';\nimport { memberText } from './unpack.js';\nimport { parseDocumentXml, type FcstdDocument } from './document.js';\nimport {\n  buildManifest,\n  initialDisposition,\n  type FaiMapping,\n  type ObjectMappingEntry,\n} from './container.js';\n\nexport interface FaiZipResult {\n  zip: Uint8Array;\n  manifest: unknown;\n  mapping: FaiMapping;\n  /** sha256 verification table for the freecad/ shadow (V1) */\n  shadowHashes: Record<string, { source: string; shadow: string }>;\n}\n\nfunction sha256(bytes: Uint8Array): string {\n  return createHash('sha256').update(bytes).digest('hex');\n}\n\nconst FREECAD_SHADOW_PREFIX = 'freecad/';\n\nexport function buildFaiZip(\n  source: FcstdArchive,\n  sourceFileName: string,\n): { result?: FaiZipResult; error?: string } {\n  const xml = memberText(source, 'Document.xml');\n  if (xml === undefined) return { error: 'Document.xml missing from source archive' };\n  const parsed = parseDocumentXml(xml);\n  if (!isOk(parsed)) return { error: parsed.error.message };\n  const doc: FcstdDocument = parsed.value;\n\n  const out: Record<string, Uint8Array | string> = {};\n  const shadowHashes: Record<string, { source: string; shadow: string }> = {};\n\n  // M2.2 — byte-exact freecad/ shadow of ALL members (including Document.xml)\n  for (const [path, bytes] of source.members) {\n    const shadowPath = FREECAD_SHADOW_PREFIX + path;\n    out[shadowPath] = bytes;\n    const h = sha256(bytes);\n    shadowHashes[path] = { source: h, shadow: h }; // same bytes → same hash\n  }\n\n  // M2.3 — baked assets: copy .brp members as-is into assets/\n  const brpOwners = new Map<string, string[]>();\n  for (const obj of doc.objects) {\n    const shapeProp = obj.properties.get('Shape');\n    if (!shapeProp) continue;\n    // brp file names appear as <File ...> inside the Part::PropertyPartShape\n    const fileEl = shapeProp.children[0]?.attributes['file'];\n    void fileEl; // file attribute lives on the wrapping element in some schemas\n    const files: string[] = [];\n    collectBrpRefs(shapeProp.valueXml ?? '', files);\n    if (files.length) brpOwners.set(obj.name, files);\n  }\n\n  const mapping: FaiMapping = { objects: [] };\n  const usedAssets = new Set<string>();\n  for (const obj of doc.objects) {\n    const entry: ObjectMappingEntry = {\n      name: obj.name,\n      type: obj.type,\n      ...initialDisposition(obj),\n      artifacts: [],\n    };\n    // attach baked .brp-derived assets where the object owns shape members\n    const brps = brpOwners.get(obj.name) ?? [];\n    for (const brp of brps) {\n      const bytes = source.members.get(brp);\n      if (!bytes) continue;\n      const assetPath = `assets/${brp}`;\n      out[assetPath] = bytes;\n      entry.artifacts.push(assetPath);\n      usedAssets.add(brp);\n    }\n    mapping.objects.push(entry);\n  }\n\n  // M2.4 — units: FCStd stores mm internally; faijs contract is mm. No\n  // scaling is applied; manifest.units records the normalized unit (D7).\n  // fflate requires Uint8Array values — strings must go through strToU8.\n  out['manifest.json'] = strToU8(JSON.stringify(buildManifest(doc, sourceFileName, readProgramVersion(doc)), null, 2));\n  out['mapping.json'] = strToU8(JSON.stringify(mapping, null, 2));\n\n  const zip = zipSync(out as Record<string, Uint8Array>, { level: 6 });\n  return { result: { zip, manifest: out['manifest.json'], mapping, shadowHashes } };\n}\n\nfunction readProgramVersion(doc: FcstdDocument): string {\n  // ProgramVersion is an attribute of <Document> captured in meta? xmldom:\n  // meta holds child property elements only, so fall back to a sane default.\n  return doc.meta.get('ProgramVersion')?.valueText ?? 'unknown';\n}\n\n/** Extract .brp file references from a serialized property value. */\nfunction collectBrpRefs(xml: string, out: string[]): void {\n  const re = /file=\"([^\"]+\\.brp)\"/g;\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(xml)) !== null) {\n    const name = m[1]!.replace(/^.*[/\\\\]/, '');\n    if (!out.includes(name)) out.push(name);\n  }\n}\n\n/** Re-export strToU8 for callers that need to embed text members. */\nexport { strToU8 };\n"]}

package/dist/fcstd/codegen.d.ts

@@ -0,0 +1,57 @@
+/**
+ * M5 — code generation: object graph + M4 call plans → model/*.fai.js.
+ *
+ * M5.1 topological order: Body.Group order wins where present; otherwise
+ * PropertyLink dependency order. Cycles / missing deps → baked (no fallback
+ * heuristics — explicit downgrade per plan §12).
+ * M5.2 lowering: params → JS constants; calls → `const partN = await cad.x(...)`;
+ * statement ids sN. Sketch contours enter as blueprint literals.
+ */
+import type { FcstdDocument } from './document.js';
+import type { CadCall } from './feature-translate.js';
+import type { Contour } from './contour.js';
+import { type Placement } from './placement.js';
+export interface GenObjectResult {
+    name: string;
+    type: string;
+    /** variable name bound in generated code (partN) or undefined when baked */
+    variable?: string;
+    calls: CadCall[];
+    disposition: 'translated' | 'baked' | 'preserved-only';
+    reason?: string;
+    /** M3 sketch verdict when the object is a sketch */
+    sketch?: {
+        level: 'L0' | 'L1' | 'L2';
+        reason?: string;
+        loopCount?: number;
+    };
+}
+export interface GenResult {
+    /** ordered translated calls (dependency order) */
+    calls: CadCall[];
+    objects: GenObjectResult[];
+    /** generated .fai.js source (single-file mode or the main/aggregate script) */
+    code: string;
+    /** M10.3: multi-file mode — one script per Body with translated geometry.
+     * Empty in single-file mode. Paths are container-relative (model/<Name>.fai.js). */
+    files: {
+        path: string;
+        code: string;
+        body: string;
+    }[];
+    /** M10.3: variable in main.fai.js holding the grouped result (multi-file mode) */
+    rootVar?: string;
+}
+/**
+ * M5.1/M5.2 — translate every object in dependency order and lower to JS.
+ * `sketchVerdict` supplies the M3 outcome per sketch object name; sketches
+ * whose contour feeds a Pad/Pocket appear as inputs.
+ */
+export declare function generateModel(doc: FcstdDocument, sketchVerdict: Map<string, {
+    level: 'L0' | 'L1' | 'L2';
+    reason?: string;
+    loopCount?: number;
+}>, sketchContours: Map<string, Contour[]>, baseName: string, 
+/** M8.3: per-object Placement (sketches + features); missing → identity */
+placements?: Map<string, Placement>): GenResult;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/fcstd/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/fcstd/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAoB,MAAM,wBAAwB,CAAC;AAExE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,KAAK,SAAS,EAA0C,MAAM,gBAAgB,CAAC;AAExF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,WAAW,EAAE,YAAY,GAAG,OAAO,GAAG,gBAAgB,CAAC;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E;AAED,MAAM,WAAW,SAAS;IACxB,kDAAkD;IAClD,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb;wFACoF;IACpF,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtD,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAqDD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAC9F,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EACtC,QAAQ,EAAE,MAAM;AAChB,2EAA2E;AAC3E,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAClC,SAAS,CA6UX"}

package/dist/fcstd/codegen.js

@@ -0,0 +1,487 @@
+import { translateObject, isJsExpr, jsExpr } from './feature-translate.js';
+import { isIdentityPlacement, quatToEulerXYZDeg } from './placement.js';
+/** Extract link dependencies relevant for ordering. */
+function depsOf(obj) {
+    const out = [];
+    const linkProps = ['Base', 'Tool', 'Profile', 'BaseFeature', 'Originals'];
+    for (const p of linkProps) {
+        const el = obj.properties.get(p)?.children[0];
+        const v = el?.attributes['value'];
+        if (v)
+            out.push(v);
+    }
+    const shapes = obj.properties.get('Shapes')?.children[0];
+    if (shapes) {
+        for (const link of shapes.children) {
+            const v = link.attributes['value'];
+            if (v)
+                out.push(v);
+        }
+    }
+    return out;
+}
+/**
+ * GOTCHA (PadTest V6 failure): a `PartDesign::Body`'s feature list lives in
+ * DIFFERENT properties depending on the FreeCAD version —
+ *   - modern (0.19+): `Model` (App::PropertyLinkList), ordered
+ *   - legacy: `Group` (App::PropertyLinkList)
+ * The Tip is `Body.Tip`. Reading only `Group` on a modern document yields an
+ * empty list → no same-Body chaining → features degrade to a loose
+ * `cad.group` of overlapping siblings (PadTest rebuilt volume ≈ 5.2× the Tip's,
+ * bboxDiag ≈ 2×). Prefer `Model`, fall back to `Group`.
+ */
+function bodyFeatureNames(obj) {
+    for (const prop of ['Model', 'Group']) {
+        const list = obj.properties.get(prop)?.children[0];
+        if (!list)
+            continue;
+        const names = [];
+        for (const link of list.children) {
+            const v = link.attributes['value'];
+            if (v)
+                names.push(v);
+        }
+        if (names.length > 0)
+            return names;
+    }
+    return [];
+}
+/**
+ * M5.1/M5.2 — translate every object in dependency order and lower to JS.
+ * `sketchVerdict` supplies the M3 outcome per sketch object name; sketches
+ * whose contour feeds a Pad/Pocket appear as inputs.
+ */
+export function generateModel(doc, sketchVerdict, sketchContours, baseName, 
+/** M8.3: per-object Placement (sketches + features); missing → identity */
+placements) {
+    const byName = new Map(doc.objects.map((o) => [o.name, o]));
+    const nodes = new Map();
+    for (const obj of doc.objects) {
+        nodes.set(obj.name, { name: obj.name, obj, deps: new Set(depsOf(obj)) });
+    }
+    // Kahn topological sort; objects with unbuilt deps fall back to insertion
+    // order iteration until progress stalls (remaining are baked with reason).
+    // M10.1: iteration order is Body.Group sequence FIRST (features of a Body
+    // process in Group order so the D-C chain follows PartDesign semantics),
+    // then leftover objects in document order.
+    const groupSeq = [];
+    for (const obj of doc.objects) {
+        if (obj.type !== 'PartDesign::Body')
+            continue;
+        for (const m of bodyFeatureNames(obj)) {
+            if (byName.has(m) && !groupSeq.includes(m))
+                groupSeq.push(m);
+        }
+    }
+    const iterationOrder = [
+        ...groupSeq,
+        ...doc.objects.map((o) => o.name).filter((n) => !groupSeq.includes(n)),
+    ];
+    const order = [];
+    const built = new Set();
+    let progress = true;
+    while (progress) {
+        progress = false;
+        for (const name of iterationOrder) {
+            const node = nodes.get(name);
+            if (built.has(node.name))
+                continue;
+            if ([...node.deps].every((d) => built.has(d) || !byName.has(d))) {
+                built.add(node.name);
+                order.push(node.name);
+                progress = true;
+            }
+        }
+    }
+    const variables = new Map();
+    const results = [];
+    const calls = [];
+    let partCounter = 0;
+    const newVar = () => `part${partCounter++}`;
+    // D-C (M9.4): same-Body features fuse cumulatively in Body.Group order —
+    // the first translated feature is the base, every later additive feature
+    // (Pad/…) unions with the chain, every subtractive one (Pocket/Cut)
+    // subtracts. cad.group is NOT used inside a Body (that is assembly
+    // semantics); cross-Body grouping stays in lower()'s root handling (M10).
+    const memberToBody = new Map();
+    for (const obj of doc.objects) {
+        if (obj.type !== 'PartDesign::Body')
+            continue;
+        for (const m of bodyFeatureNames(obj)) {
+            if (!memberToBody.has(m))
+                memberToBody.set(m, obj.name);
+        }
+    }
+    const chainVar = new Map(); // body name → accumulated var
+    for (const name of order) {
+        const node = nodes.get(name);
+        const obj = node.obj;
+        if (obj.type === 'Sketcher::SketchObject') {
+            const verdict = sketchVerdict.get(name);
+            const contours = sketchContours.get(name);
+            const usable = !!verdict &&
+                verdict.level !== 'L2' &&
+                (verdict.loopCount ?? 0) > 0 &&
+                !!contours &&
+                contours.length > 0;
+            if (usable) {
+                // M6 wiring: emit a real `cad.sketch({contours})` creator so the
+                // solved contour becomes a face variable the Pad/Pocket/Extrusion/
+                // Revolution features below can consume.
+                const v = newVar();
+                variables.set(name, v);
+                const sketchCall = {
+                    out: v, op: 'cad.sketch', source: name, inputs: [], params: { contours },
+                };
+                calls.push(sketchCall);
+                results.push({
+                    name, type: obj.type, variable: v, calls: [sketchCall], disposition: 'translated',
+                    sketch: verdict,
+                });
+            }
+            else {
+                results.push({
+                    name, type: obj.type, calls: [], disposition: 'baked',
+                    reason: verdict?.reason ?? (contours ? 'sketch-not-solved' : 'sketch-no-contours'), sketch: verdict,
+                });
+            }
+            continue;
+        }
+        if (obj.type === 'App::Origin' || obj.type === 'App::Plane' || obj.type === 'App::Line') {
+            results.push({ name, type: obj.type, calls: [], disposition: 'preserved-only', reason: 'datum' });
+            continue;
+        }
+        // Sketches are now real face variables (see the Sketcher::SketchObject
+        // branch above), so every dependency that resolves to one flows through.
+        const verdict = translateObject(obj, (dep) => {
+            const v = variables.get(dep);
+            return v !== undefined ? v : undefined;
+        }, doc.objects);
+        node.verdict = verdict;
+        if (verdict.kind === 'translated') {
+            // rename output vars to partN sequence
+            for (const call of verdict.calls) {
+                const v = newVar();
+                variables.set(call.out, v);
+                // remap inputs that were intermediate (Pocket_cut) or named outputs
+                call.inputs = call.inputs.map((i) => variables.get(i) ?? i);
+                call.out = v;
+                calls.push(call);
+            }
+            // M8.3: features build in sketch-local coordinates (cad.sketch lays the
+            // face on local XY; extrude runs along local +Z). Re-orient the final
+            // solid by the PROFILE SKETCH's Placement: rotate_euler then translate,
+            // so the result lands where FreeCAD puts it. Identity placements emit
+            // nothing.
+            // GOTCHA (PadTest V6, relErr 3.20%): a PartDesign feature's geometry is
+            // built in the SKETCH frame, but FreeCAD may store a DIFFERENT Placement
+            // on the feature object itself (Pad001: sketch P=(10,0,0)
+            // Q=(0,.7071,0,.7071) vs feature P=0 Q=(0,.7071,.7071,0)) — re-orienting
+            // by the feature's own frame drops the sketch origin offset and rotates
+            // the extrude axis into the wrong direction (−3.20% volume, centroid
+            // off 1.67). The sketch's Placement is the authoritative frame for the
+            // built geometry; fall back to the feature's own for sketchless features.
+            const lastVar = verdict.calls.at(-1)?.out;
+            const sketchLink = obj.properties.get('Sketch')?.children[0]?.attributes['value'];
+            const pl = (sketchLink ? placements?.get(sketchLink) : undefined) ?? placements?.get(name);
+            if (lastVar && pl && !isIdentityPlacement(pl)) {
+                let cur = lastVar;
+                const euler = quatToEulerXYZDeg(pl.q);
+                const isRotation = Math.abs(euler[0]) > 1e-9 || Math.abs(euler[1]) > 1e-9 || Math.abs(euler[2]) > 1e-9;
+                if (isRotation) {
+                    const rv = newVar();
+                    variables.set(cur, rv); // map old name → rotated var for consumers
+                    calls.push({ out: rv, op: 'cad.rotate_euler', source: name, inputs: [cur], params: { anglesDeg: euler } });
+                    cur = rv;
+                }
+                const needsTranslate = Math.abs(pl.p[0]) > 1e-9 || Math.abs(pl.p[1]) > 1e-9 || Math.abs(pl.p[2]) > 1e-9;
+                if (needsTranslate) {
+                    const tv = newVar();
+                    variables.set(cur, tv);
+                    calls.push({ out: tv, op: 'cad.translate', source: name, inputs: [cur], params: { offset: [...pl.p] } });
+                    cur = tv;
+                }
+                // the object's variable is now the fully placed result
+                variables.set(name, cur);
+            }
+            // M9.4 (D-C): fold the feature into its Body's chain — AFTER the placement
+            // step so the chain accumulates the PLACED feature shape. Pocket/Cut
+            // subtract from the chain; everything else unions onto it. The first
+            // feature in the Body's feature list (Model/Group) order becomes the
+            // chain base — no cad.group inside a Body; consumers (M10) read chainVar.
+            // GOTCHA (PadTest V6): folding the UNPLACED feature var (the old order)
+            // left the chain head in sketch-local space while each feature's Placement
+            // was applied to a separate, unused variable → the exported body spanned
+            // both the local and the placed copies (~2× bboxDiag, ~5× volume).
+            const body = memberToBody.get(name);
+            const isSubtractive = obj.type === 'PartDesign::Pocket' || obj.type === 'Part::Cut';
+            if (body) {
+                const prev = chainVar.get(body);
+                // UpToLast/UpToFirst: FreeCAD's "up to" support is the Body's ACCUMULATED
+                // shape, NOT only the immediate BaseFeature link — retarget the kernel
+                // ref at the chain head (prev). GOTCHA (PadTest V6): truncating against
+                // the immediate BaseFeature (a small Pad001 disc) left an 8.06% volume
+                // deficit vs the Tip; against the accumulated chain it drops to 3.20%
+                // (bbox already exact at delta 0).
+                if (prev) {
+                    for (const c of verdict.calls) {
+                        if (c.op === 'cad.extrude' && c.params.baseFeature !== undefined) {
+                            // GOTCHA (PadTest V6 residual): the up-to extrude builds its
+                            // prism in the SKETCH-LOCAL frame, but the chain head (prev)
+                            // lives in the PLACED (global) frame. FreeCAD's boolean runs in
+                            // one frame — so transform prev back into the sketch frame
+                            // first: local = R^-1(global - p). Feeding the placed chain var
+                            // directly silently truncates at the wrong face (Pad002 truth
+                            // AddShape 48199 vs rebuilt deficit ~9108 mm^3 → 3.2% total).
+                            const needsInverse = pl !== undefined && !isIdentityPlacement(pl);
+                            if (needsInverse && pl) {
+                                const invQ = [
+                                    -pl.q[0], -pl.q[1], -pl.q[2], pl.q[3],
+                                ];
+                                const invEuler = quatToEulerXYZDeg(invQ);
+                                const tv = newVar();
+                                const tvCall = {
+                                    out: tv, op: 'cad.translate', source: name,
+                                    inputs: [prev], params: { offset: [-pl.p[0], -pl.p[1], -pl.p[2]] },
+                                };
+                                const rv = newVar();
+                                const rvCall = {
+                                    out: rv, op: 'cad.rotate_euler', source: name,
+                                    inputs: [tv], params: { anglesDeg: invEuler },
+                                };
+                                // insert BEFORE the extrude call: faijs is a statement
+                                // language — `baseFeature: partN` referencing a later
+                                // statement is E_REFERENCE (parser rejects forward refs).
+                                const at = calls.indexOf(c);
+                                calls.splice(at < 0 ? calls.length : at, 0, tvCall, rvCall);
+                                c.params.baseFeature = jsExpr(rv);
+                            }
+                            else {
+                                c.params.baseFeature = jsExpr(prev);
+                            }
+                        }
+                    }
+                }
+                const featureVar = variables.get(name) ?? verdict.calls.at(-1).out;
+                if (!prev) {
+                    chainVar.set(body, featureVar); // base feature
+                }
+                else if (isSubtractive && verdict.calls.at(-1).op === 'cad.subtract' && verdict.calls.at(-1).inputs.includes(prev)) {
+                    // Pocket already subtracted from the chain var itself (BaseFeature
+                    // resolved to the chain) — its output IS the new chain head; no
+                    // extra subtract (would cut twice).
+                    chainVar.set(body, featureVar);
+                }
+                else if (isSubtractive) {
+                    const nv = newVar();
+                    calls.push({ out: nv, op: 'cad.subtract', source: name, inputs: [prev, featureVar], params: {} });
+                    chainVar.set(body, nv);
+                }
+                else {
+                    const nv = newVar();
+                    calls.push({ out: nv, op: 'cad.union', source: name, inputs: [prev, featureVar], params: {} });
+                    chainVar.set(body, nv);
+                }
+            }
+            results.push({ name, type: obj.type, variable: verdict.calls.at(-1)?.out, calls: verdict.calls, disposition: 'translated', reason: verdict.reason });
+        }
+        else if (verdict.kind === 'baked') {
+            results.push({ name, type: obj.type, calls: [], disposition: 'baked', reason: verdict.reason });
+        }
+        else {
+            results.push({ name, type: obj.type, calls: [], disposition: 'preserved-only', reason: verdict.reason });
+        }
+    }
+    // also mark unreachable (cycle) objects as baked
+    for (const obj of doc.objects) {
+        if (!results.some((r) => r.name === obj.name)) {
+            results.push({ name: obj.name, type: obj.type, calls: [], disposition: 'baked', reason: 'dependency-cycle' });
+        }
+    }
+    // M10.3/M10.5 — split by Body: calls whose source object belongs to a Body
+    // (including the chain union/subtract calls emitted for it) go to
+    // model/<BodyName>.fai.js; everything else (loose Part features) stays in
+    // main.fai.js. When no Body has geometry, everything lands in main (the
+    // single-file shape). Aggregate entry groups per-file roots via cad.group.
+    const callBody = new Map();
+    for (const r of results) {
+        const b = memberToBody.get(r.name);
+        if (b)
+            for (const c of r.calls)
+                callBody.set(c.out, b);
+    }
+    const bodiesWithGeo = new Set();
+    for (const b of new Set(memberToBody.values())) {
+        if (chainVar.has(b))
+            bodiesWithGeo.add(b);
+    }
+    const files = [];
+    let code;
+    let rootVar;
+    if (bodiesWithGeo.size > 0) {
+        const mainCalls = [];
+        const perBody = new Map();
+        // M10c partition in DEPENDENCY ORDER: `calls` is already topologically
+        // sorted, so ONE forward pass assigns each call — to its own source's Body
+        // when known (`callBody`), else to the Body its first body-owned input went
+        // to. GOTCHA (PadTest V6): the previous implementation re-assigned such
+        // calls by APPENDING them to the end of the Body file, which broke
+        // dependency order — a Body file ended up referencing a variable declared
+        // further down (`let` TDZ ReferenceError at run time: `part8` used `part6`).
+        // Filtering `calls` in place preserves the topological order.
+        const assigned = new Map(); // call.out → Body file name
+        for (const c of calls) {
+            const own = callBody.get(c.out);
+            const viaInput = c.inputs.map((inp) => assigned.get(inp)).find((b) => b !== undefined);
+            const b = own !== undefined && bodiesWithGeo.has(own) ? own : viaInput;
+            if (b !== undefined && bodiesWithGeo.has(b)) {
+                if (!perBody.has(b))
+                    perBody.set(b, []);
+                perBody.get(b).push(c);
+                assigned.set(c.out, b);
+            }
+            else {
+                mainCalls.push(c);
+            }
+        }
+        for (const b of bodiesWithGeo) {
+            const bodyCalls = perBody.get(b) ?? [];
+            // terminal: alias the chain head to <Body>_out so the aggregate entry
+            // has a stable, name-independent reference to each Body's result.
+            const head = chainVar.get(b);
+            const withTerminal = [
+                ...bodyCalls,
+                { out: `${b}_out`, op: 'identity', source: b, inputs: [head], params: {} },
+            ];
+            files.push({ path: `model/${b}.fai.js`, code: lowerBody(withTerminal, `${baseName}/${b}`, b), body: b });
+        }
+        // main.fai.js: aggregate the per-Body terminals via cad.group. M10c:
+        // cross-file references close through the standard relative-import
+        // contract (module-registry D6) — each Body module's terminal alias
+        // `<Body>_out` is its live shape, so a named import binds it.
+        const lines = [];
+        lines.push(`// Generated by faijs FCStd port — ${baseName} (aggregate entry)`);
+        lines.push(`// Units: mm (faijs contract; FCStd internal units are mm)`);
+        const members = [...bodiesWithGeo].map((b) => `${b}_out`);
+        // Always import the per-Body terminals: the aggregate entry references
+        // `<Body>_out` in BOTH the cad.group (multi-Body) and the single-Body alias
+        // path, so a missing import is a SEC_FREE_IDENT parse error (GOTCHA: the
+        // single-Body branch previously emitted `let part_out = <Body>_out;` with
+        // no import). `mainCalls` may still be empty here.
+        if (members.length >= 1) {
+            for (const b of bodiesWithGeo) {
+                lines.push(`import { ${b}_out } from './${b}.fai.js'; // module ${b}`);
+            }
+        }
+        for (const c of mainCalls) {
+            const id = `s${lines.length - 2}`;
+            lines.push(`let ${c.out} = ${c.op}(${renderArgs(c)}); // ${id} ${c.source}`);
+        }
+        if (members.length > 1) {
+            rootVar = 'part_out';
+            lines.push(`let part_out = cad.group({ members: [${members.join(', ')}] });`);
+        }
+        else if (members.length === 1) {
+            // single Body: the imported terminal IS the result — alias keeps a
+            // stable root name for executors
+            rootVar = members[0];
+            lines.push(`let part_out = ${rootVar}; // single-Body aggregate`);
+            rootVar = 'part_out';
+        }
+        code = lines.join('\n') + '\n';
+    }
+    else {
+        code = lower(calls, baseName);
+    }
+    return { calls, objects: results, code, files, rootVar };
+}
+/** M10.3 — lower one Body's calls; the last entry is the terminal alias
+ * `<Body>_out` (plain JS assignment — faijs has no identity op). */
+function lowerBody(calls, label, body) {
+    const lines = [];
+    lines.push(`// Generated by faijs FCStd port — ${label}`);
+    lines.push(`// Units: mm (faijs contract; FCStd internal units are mm)`);
+    for (const call of calls) {
+        if (call.op === 'identity') {
+            // terminal alias: `let <Body>_out = <chain head>;`
+            lines.push(`let ${call.out} = ${call.inputs[0]}; // s? ${body} terminal`);
+            continue;
+        }
+        const id = `s${lines.length - 2}`;
+        lines.push(`let ${call.out} = ${call.op}(${renderArgs(call)}); // ${id} ${call.source}`);
+    }
+    return lines.join('\n') + '\n';
+}
+/** M5.2 — lower the call plan to .fai.js source. faijs syntax: top-level
+ * statement flow with `let partN = cad.x(...)`; no wrapper function. */
+function lower(calls, baseName) {
+    const lines = [];
+    lines.push(`// Generated by faijs FCStd port — ${baseName}`);
+    lines.push(`// Units: mm (faijs contract; FCStd internal units are mm)`);
+    for (const call of calls) {
+        const id = `s${lines.length - 2}`; // statement id sN
+        const args = renderArgs(call);
+        lines.push(`let ${call.out} = ${call.op}(${args}); // ${id} ${call.source}`);
+    }
+    // final shape: union of root calls that nobody consumes; faijs scripts
+    // end with the output-producing statement (no return, per fixtures).
+    const consumed = new Set(calls.flatMap((c) => c.inputs));
+    const roots = calls.filter((c) => !consumed.has(c.out)).map((c) => c.out);
+    if (roots.length > 1) {
+        lines.push(`let part_out = cad.group({ members: [${roots.join(', ')}] });`);
+    }
+    else if (roots.length === 0) {
+        lines.push(`// no translated geometry (all baked)`);
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * M5.2 — render one IR value as JS. Plain values JSON-encode (byte-identical to
+ * the pre-JsExpr output); a `JsExpr` marker renders verbatim, and a container
+ * holding one renders element-wise so the expression survives into the source.
+ */
+function renderValue(v) {
+    if (isJsExpr(v))
+        return v.__jsExpr;
+    if (Array.isArray(v)) {
+        if (v.some(isJsExpr))
+            return `[${v.map(renderValue).join(', ')}]`;
+        return JSON.stringify(v);
+    }
+    if (v && typeof v === 'object') {
+        const entries = Object.entries(v);
+        if (entries.some(([, val]) => containsJsExpr(val))) {
+            return `{ ${entries.map(([k, val]) => `${k}: ${renderValue(val)}`).join(', ')} }`;
+        }
+        return JSON.stringify(v);
+    }
+    return JSON.stringify(v);
+}
+/** True when a value is or (recursively) contains a `JsExpr` marker. */
+function containsJsExpr(v) {
+    if (isJsExpr(v))
+        return true;
+    if (Array.isArray(v))
+        return v.some(containsJsExpr);
+    if (v && typeof v === 'object')
+        return Object.values(v).some(containsJsExpr);
+    return false;
+}
+function renderArgs(call) {
+    const positional = [
+        ...call.inputs.map((i) => i),
+        ...(call.literals ?? []).map((l) => renderValue(l)),
+    ].filter((s) => s.length > 0); // M7.1: drop empty entries so we never emit `(, `
+    const named = [];
+    for (const [k, v] of Object.entries(call.params ?? {})) {
+        if (v === undefined)
+            continue;
+        named.push(`${k}: ${renderValue(v)}`);
+    }
+    const namedBlock = named.length ? `{ ${named.join(', ')} }` : '';
+    // M7.1: no leading comma when there are no positional args — a call with only
+    // named params must render as `cad.sketch({ ... })`, never `cad.sketch(, {...})`.
+    const rest = namedBlock ? (positional.length ? `, ${namedBlock}` : namedBlock) : '';
+    return `${positional.join(', ')}${rest}`;
+}
+//# sourceMappingURL=codegen.js.map