@faicad/faijs 0.30.9 → 0.32.2

package/dist/fcstd/feature-translate.js

@@ -1,968 +0,0 @@
-import { parseExpressionEngine, evalWithDoc } from './expressions.js';
-import { placementOf, quatToMatrix } from './placement.js';
-import { shapeBrpFile } from './external-geo.js';
-/**
- * Wrap raw JS source as a verbatim argument (`JsExpr`).
- *
- * @param code - the JS expression source to emit in the argument position.
- * @returns the `JsExpr` marker carrying that source.
- */
-export function jsExpr(code) {
-    return { __jsExpr: code };
-}
-/**
- * True for a `JsExpr` marker (used by M5 to render verbatim).
- *
- * @param v - the value to test.
- * @returns true when `v` is a `JsExpr` marker.
- */
-export function isJsExpr(v) {
-    return typeof v === 'object' && v !== null && typeof v.__jsExpr === 'string';
-}
-/**
- * H7 (hole_puzzle corpus, 2026-09-20): marker input for a subtract whose base
- * is implied by the Body's feature order (no explicit BaseFeature property).
- * Codegen retargets this at the chain head when folding the feature into its
- * Body chain. Never a legal variable name (contains `::`), so it cannot be
- * confused with a real input.
- */
-export const BODY_CHAIN_BASE = '::body-chain-base::';
-/** M4.1 whitelist (plan §5.5.5 measurable types only). */
-const WHITELIST = new Set([
-    'Part::Box',
-    'Part::Cylinder',
-    'Part::Cut',
-    'Part::MultiFuse',
-    'Part::Extrusion',
-    'PartDesign::Pad',
-    'PartDesign::Pocket',
-    'PartDesign::Revolution',
-    'PartDesign::LinearPattern',
-    'PartDesign::PolarPattern',
-    'PartDesign::Fillet',
-    'PartDesign::Chamfer',
-    // M13.1 (probed on real corpus — fcstd-port/tools/probe-m13-types.ts):
-    // Part::Compound carries a Links PropertyLinkList; Part::Sphere carries
-    // Radius (+ optional Angle like Cylinder).
-    'Part::Compound',
-    'Part::Sphere',
-]);
-/**
- * True when the object type is on the M4.1 translation whitelist.
- *
- * @param type - the FCStd object type, e.g. "Part::Box".
- * @returns true when the type is whitelisted for translation.
- */
-export function isWhitelisted(type) {
-    return WHITELIST.has(type);
-}
-/**
- * H10 (plan §3.1/§3.5): C4's Python exception, decided by PROPERTY presence —
- * NOT by the `Python` type-name suffix. Matches the library profile's
- * pythonObjects口径 (profile.mjs: type contains "Python" or carries
- * Python/Proxy properties); here only the property evidence qualifies, so a
- * Python-suffixed type without the property stays a plain translation gap.
- * @param obj - the FCStd object to inspect.
- * @returns true when the object is a Python-scripted feature whose serialized
- *   shape is opaque (legitimate `python-baked` under C4).
- */
-export function isPythonOpaque(obj) {
-    for (const [name, prop] of obj.properties) {
-        if (name === 'Python' || name === 'Proxy')
-            return true;
-        if (prop.type === 'App::PropertyPythonObject')
-            return true;
-    }
-    return false;
-}
-function propNum(obj, name) {
-    // M11.1: an ExpressionEngine binding overrides the stored <Float> value
-    // (FreeCAD recomputes bound properties from expressions on load). A
-    // non-constant binding is reported via exprBindingOf, not guessed here.
-    const bound = expressionBindingOf(obj, name);
-    if (bound && bound.value !== undefined)
-        return bound.value;
-    const p = obj.properties.get(name);
-    if (!p)
-        return undefined;
-    const el = p.children[0];
-    const v = el?.attributes['value'];
-    return v === undefined ? undefined : Number(v);
-}
-/**
- * M11.1/M11.2: the ExpressionEngine binding for `name`, if any. `value` is
- * undefined for non-constant expressions (references/arithmetic) — the caller
- * must bake with an explicit reason instead of estimating.
- *
- * @param obj - the FCStd object whose ExpressionEngine to inspect.
- * @param name - the property name to look up.
- * @returns the binding for `name`, or undefined when the object has no
- *   ExpressionEngine binding for it.
- */
-export function expressionBindingOf(obj, name) {
-    const bindings = parseExpressionEngine(obj.properties.get('ExpressionEngine'));
-    if (bindings.length === 0)
-        return undefined;
-    const norm = (p) => (p.startsWith('.') ? p.slice(1) : p);
-    const b = bindings.find((b) => norm(b.path) === name);
-    // P1-1（参数载体）：非常量绑定尝试三跳解析（<<Label>>.Alias → 单元格值）。
-    // docObjects 由 translateObject 入口注入（模块级上下文，见 docContext）。
-    if (b && b.value === undefined && docContext) {
-        const v = evalWithDoc(b.expression, docContext);
-        if (v !== undefined)
-            return { ...b, value: v };
-    }
-    return b;
-}
-/** P1-1: translateObject 入口注入的文档对象上下文（表达式的引用解析需要全文档）。 */
-let docContext;
-/**
- * M11.2: detect a non-constant expression binding on a property.
- *
- * @param obj - the FCStd object whose ExpressionEngine to inspect.
- * @param name - the property name to look up.
- * @returns true when `name` has a binding that is NOT a constant expression.
- */
-export function hasNonConstantBinding(obj, name) {
-    const b = expressionBindingOf(obj, name);
-    return b !== undefined && b.value === undefined;
-}
-function propBool(obj, name) {
-    const el = obj.properties.get(name)?.children[0];
-    return el?.attributes['value'] === 'true';
-}
-function propLink(obj, name) {
-    const el = obj.properties.get(name)?.children[0];
-    const v = el?.attributes['value'];
-    return v && v.length > 0 ? v : undefined;
-}
-/** Read a string-valued property (e.g. ReferenceAxis). */
-function propStr(obj, name) {
-    const el = obj.properties.get(name)?.children[0];
-    const v = el?.attributes['value'];
-    return v && v.length > 0 ? v : undefined;
-}
-const PAD_TYPES = {
-    '0': 'Length', '1': 'UpToLast', '2': 'UpToFirst', '3': 'UpToFace', '4': 'TwoLengths',
-    Length: 'Length', UpToLast: 'UpToLast', UpToFirst: 'UpToFirst', UpToFace: 'UpToFace', TwoLengths: 'TwoLengths',
-};
-const POCKET_TYPES = {
-    '0': 'Length', '1': 'ThroughAll', '2': 'UpToFirst', '3': 'UpToFace', '4': 'TwoLengths',
-    Length: 'Length', ThroughAll: 'ThroughAll', UpToFirst: 'UpToFirst', UpToFace: 'UpToFace', TwoLengths: 'TwoLengths',
-};
-/**
- * Read the Pad/Pocket `Type` enumeration of an object (M9.1).
- *
- * @param obj - the FCStd Pad or Pocket object.
- * @param kind - which type-enum table to apply (Pad vs Pocket labels differ).
- * @returns the parsed feature type; 'Length' when Type is missing, 'unknown'
- *   when the stored label/index is not recognized.
- */
-export function featureTypeOf(obj, kind) {
-    const el = obj.properties.get('Type')?.children[0];
-    const raw = el?.attributes['value'];
-    if (raw === undefined || raw === '')
-        return 'Length';
-    const table = kind === 'pad' ? PAD_TYPES : POCKET_TYPES;
-    return table[raw] ?? 'unknown';
-}
-/** Read an App::PropertyVector (`value="x y z"`) as a Vec3. */
-function propVec(obj, name) {
-    const raw = propStr(obj, name);
-    if (!raw)
-        return undefined;
-    const parts = raw.trim().split(/\s+/).map(Number);
-    if (parts.length !== 3 || parts.some((n) => !Number.isFinite(n)))
-        return undefined;
-    return [parts[0], parts[1], parts[2]];
-}
-/**
- * Read an `App::PropertyLinkSub`: the target object name plus its sub-element
- * names. FreeCAD serializes this as
- * `<LinkSub value="Pad001" count="2"><Sub value="Edge17"/><Sub value="Edge18"/></LinkSub>`.
- */
-function propLinkSub(obj, name) {
-    const el = obj.properties.get(name)?.children[0];
-    if (!el)
-        return undefined;
-    const target = el.attributes['value'];
-    if (!target || target.length === 0)
-        return undefined;
-    const subs = [];
-    for (const sub of el.children) {
-        const v = sub.attributes['value'];
-        if (v)
-            subs.push(v);
-    }
-    return { obj: target, subs };
-}
-/**
- * Parse FreeCAD edge sub-element names (`Edge17`) into 1-based ordinals.
- * Returns undefined when any entry is not an `EdgeN` reference (a Face/Vertex
- * selection cannot be expressed as a faijs `EdgeTopoRef`).
- */
-function parseEdgeSubs(subs) {
-    const out = [];
-    for (const s of subs) {
-        const m = /^Edge(\d+)$/.exec(s);
-        if (!m)
-            return undefined;
-        const n = Number(m[1]);
-        if (!Number.isInteger(n) || n < 1)
-            return undefined;
-        out.push(n);
-    }
-    return out;
-}
-/**
- * Parse a FreeCAD face sub-element name (`Face3`) into a 1-based ordinal.
- * Returns undefined when the selection is not a plain `FaceN` reference (e.g. a
- * TNaming-modified name `"Face__20f_..."`, an `Edge*`/`Vertex*` selection, or a
- * multi-face set) so the caller can bake with an explicit reason instead of
- * guessing. The ordinal is consumed by `cad.faceRef`, whose face enumeration
- * order is calibrated to match FreeCAD's `FaceN` (plan §4.3-C2 / R-A).
- */
-function parseFaceSub(subs) {
-    if (subs.length !== 1)
-        return undefined;
-    const m = /^Face(\d+)$/.exec(subs[0]);
-    if (!m)
-        return undefined;
-    const n = Number(m[1]);
-    return Number.isInteger(n) && n >= 1 ? n : undefined;
-}
-/**
- * Build the `edges` argument for a fillet/chamfer call: one `cad.edgeRef(base, N)`
- * expression per FreeCAD edge ordinal. The refs must be resolved against the
- * live base shape at run time (an `EdgeTopoRef` is a two-face role pair, which
- * only the runtime naming layer knows), so they enter the IR as `JsExpr`.
- */
-function edgeRefArgs(baseVar, ordinals) {
-    return ordinals.map((n) => jsExpr(`cad.edgeRef(${baseVar}, ${n})`));
-}
-/**
- * Parse a PartDesign ReferenceAxis reference into a 3D axis + pivot point.
- *
- * FreeCAD stores this as an `App::PropertyLinkSub` string that either names a
- * standard body axis (`V_Axis` / `H_Axis` / `N_Axis`, or the generic `Axis`
- * that PartDesign revolves around = +Z) or an edge/vertex of another feature.
- * Edge/vertex axes require resolving referenced geometry, which the port does
- * not yet do (explicit downgrade, no silent loss).
- *
- * @param ref - the ReferenceAxis (or Direction) LinkSub string, may be undefined.
- * @returns a unit axis and pivot point, or undefined when the reference names
- *   edge/vertex geometry (unsupported).
- */
-export function parseReferenceAxis(ref) {
-    const at = [0, 0, 0];
-    if (!ref)
-        return { axis: [0, 0, 1], at };
-    if (/Edge|Vertex/i.test(ref))
-        return undefined; // geometry-referenced axis: unsupported
-    // Standard body axes. PartDesign LinearPattern stores Direction as a LinkSub
-    // naming X_Axis/Y_Axis/Z_Axis; older ReferenceAxis uses V_Axis/H_Axis/N_Axis.
-    if (/X_Axis|H_Axis/i.test(ref))
-        return { axis: [1, 0, 0], at };
-    if (/Y_Axis/i.test(ref))
-        return { axis: [0, 1, 0], at };
-    if (/Z_Axis|V_Axis/i.test(ref))
-        return { axis: [0, 0, 1], at };
-    if (/N_Axis/i.test(ref))
-        return { axis: [1, 0, 0], at }; // legacy mapping, keep stable
-    // The generic "Axis" or anything else defaults to +Z (sketch normal)
-    return { axis: [0, 0, 1], at };
-}
-/**
- * Resolve a Pad/Pocket profile link. Modern files use `Profile`; files saved
- * by FreeCAD ≤ 0.19 store the sketch directly under `Sketch` (observed in
- * PadTest.fcstd, ProgramVersion 0.14/0.17 era).
- */
-function profileLink(obj) {
-    return propLink(obj, 'Profile') ?? propLink(obj, 'Sketch');
-}
-/**
- * Placement position (translation) of an object.
- *
- * @param obj - the FCStd object to read.
- * @returns the (Px, Py, Pz) translation from its Placement, or (0,0,0) when absent.
- */
-export function placementPos(obj) {
-    // Property → <PropertyPlacement Px=... Py=... Pz=.../>
-    const pp = obj.properties.get('Placement')?.children[0];
-    if (!pp)
-        return [0, 0, 0];
-    return [
-        Number(pp.attributes['Px'] ?? 0),
-        Number(pp.attributes['Py'] ?? 0),
-        Number(pp.attributes['Pz'] ?? 0),
-    ];
-}
-/**
- * A frozen `.brp` shape delivered through the container's `assets/` becomes an
- * addressable Shape via `cad.import_brep` — the **platform** BREP-asset import
- * op (`api/import-brep.ts`), which reads through the host asset resolver and
- * returns a BREP-backed Shape the rest of the chain can consume.
- *
- * GOTCHA (2026-09-21, found while verifying ArchDetail): the shape-asset rounds
- * used to emit a made-up `cad.import_shape`, which is **not** in the cad
- * namespace. 42 of the 50 corpus products therefore parsed clean but could not
- * RUN — `cliCheck` validates syntax and script-local references, never the
- * callee's existence, so only a real `run --mode brep` exposes this.
- *
- * Contract details:
- * - asset: the asset file name WITHOUT extension — that is the key rule of the
- *   documented directory mode of `FsAssetResolver` (`key = basename(file)`),
- *   which is how a container's `assets/` directory is exposed.
- *
- * C6 (non-solid first-class): `cad.import_brep` always imports with
- * `allowNonSolid` (wire/face/shell are first-class). There is no `format`
- * hint — the op goes straight to `loadBrep` on the OCCT kernel, which needs
- * no format detection. Booleans / up-to targets that require a solid still
- * fail at the **use site**, never at the import site.
- *
- * @param obj - the FCStd object whose frozen shape is being imported.
- * @param assetFile - the `.brp` member name recorded on the object's Shape/SubShape property.
- * @returns the `cad.import_brep` call binding `obj.name` to the imported geometry.
- */
-function shapeAssetCall(obj, assetFile) {
-    const asset = assetFile.replace(/^.*[/\\]/, '').replace(/\.brp$/i, '');
-    return {
-        out: obj.name, op: 'cad.import_brep', source: obj.name, inputs: [],
-        params: { asset },
-    };
-}
-/**
- * M4 translate one object. `inputVar` maps a dependency object name to the
- * variable holding its geometry (sketch contours or prior solid).
- *
- * `docObjects` (optional) is the full document object list — needed by the
- * UpToFace datum-plane path to read the target plane's Placement (plan
- * extrude-upto-face §4.3-C1). When absent, UpToFace keeps the explicit bake.
- *
- * @param obj - the FCStd object to translate.
- * @param inputVar - resolves a dependency object name to the variable holding
- *   its geometry (sketch contours or prior solid).
- * @param docObjects - the full document object list, needed by the UpToFace
- *   datum-plane path; optional.
- * @param shapeCarriers - objects whose Shape is stored as a .brp member; optional.
- * @param brokenShapeAssets - objects whose Shape `file` attribute points at a missing/empty member (explicit gap); optional.
- * @returns the cad-op call plan, or an explicit bake/preserve verdict with reason.
- */
-export function translateObject(obj, inputVar, docObjects, 
-/** H7: names of objects whose Shape is stored as a .brp member (probed from the ZIP). */
-shapeCarriers, 
-/** E4: objects whose Shape `file` attribute points at a missing/empty member. */
-brokenShapeAssets) {
-    // P1-1（参数载体）：注入文档上下文，让 expressionBindingOf 能做
-    // <<Label>>.Alias 三跳解析（引用算术需要全文档找 Spreadsheet 数据源）。
-    if (docObjects)
-        docContext = docObjects;
-    // E4 (H12): a Shape/SubShape `file` attribute whose member is missing or
-    // zero-bytes in the archive is a BROKEN asset, not a shape-asset — surface
-    // it as an explicit convert-time gap instead of letting the object fall
-    // through to python-opaque (which would silently swallow the defect).
-    if (brokenShapeAssets?.has(obj.name)) {
-        return { kind: 'baked', reason: 'shape-asset-broken: frozen .brp member missing or empty' };
-    }
-    // H7 follow-up (Body-less CAM corpus, 2026-09-20): a SubShape property whose
-    // .brp member exists is the feature's own RESULT cache — the pocketed/
-    // filleted geometry is already a fact delivered via assets/. shape-asset
-    // beats an honest-but-useless dependency gap for Body-less files. Only
-    // SubShape qualifies (Pads also carry Shape in these files — they must keep
-    // the normal translation path).
-    if (shapeCarriers?.has(obj.name) && obj.properties.has('SubShape')) {
-        // The result cache is a real, addressable solid: downstream features
-        // (Fillet Base→Pocket, Cut Base→…) must resolve it as a variable, so the
-        // verdict emits a real load call instead of zero calls (hole_puzzle
-        // GOTCHA: zero-call objects got no codegen variable and consumers gapped
-        // with fillet-missing-base / cut-missing-dependency).
-        const assetFile = obj.properties.get('SubShape')?.children[0]?.attributes['file'] ?? `${obj.name}.SubShape.brp`;
-        return {
-            kind: 'translated',
-            calls: [shapeAssetCall(obj, assetFile)],
-            reason: 'shape-asset',
-        };
-    }
-    if (!isWhitelisted(obj.type)) {
-        // GOTCHA (EngineBlock corpus, 2026-09-20): Shape-asset evidence PRECEDES
-        // python-opaque. Draft circles carry Proxy (python evidence) AND a real
-        // Shape .brp member; python-opaque baked them silently and downstream
-        // Part::Extrusion gapped with extrusion-missing-base. Geometry is an
-        // existing fact — import it.
-        if (shapeCarriers?.has(obj.name)) {
-            const assetFile = shapeBrpFile(obj) ?? `${obj.name}.Shape.brp`;
-            return {
-                kind: 'translated',
-                calls: [shapeAssetCall(obj, assetFile)],
-                reason: 'shape-asset',
-            };
-        }
-        // H10: property-evidenced Python features bake legitimately (C4) —
-        // auditMapping renames this reason to `python-baked`. Everything else is
-        // a plain translation gap.
-        if (isPythonOpaque(obj))
-            return { kind: 'baked', reason: 'python-opaque' };
-        // H7 first cut: a Part::Feature is a pure Shape carrier (corpus probe:
-        // property surface is Shape [+ShapeMaterial] only; geometry lives in the
-        // ZIP's .brp member). With shape evidence there is nothing to translate —
-        // the geometry is delivered via assets/ (build-fai-zip M2.3 already copies
-        // it), so record `translated` with no cad calls. Without evidence it is an
-        // explicit gap, never a silent bake.
-        if (obj.type === 'Part::Feature') {
-            if (shapeCarriers?.has(obj.name))
-                return { kind: 'translated', calls: [], reason: 'shape-asset' };
-            return { kind: 'baked', reason: 'shape-asset-missing' };
-        }
-        return { kind: 'baked', reason: `type-not-whitelisted: ${obj.type}` };
-    }
-    const out = obj.name; // M5 renames to partN
-    switch (obj.type) {
-        case 'Part::Box': {
-            const l = propNum(obj, 'Length') ?? 0;
-            const w = propNum(obj, 'Width') ?? 0;
-            const h = propNum(obj, 'Height') ?? 0;
-            // FCStd Box: corner at Placement, extends +X/+Y/+Z
-            const [x, y, z] = placementPos(obj);
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.box', source: obj.name, inputs: [],
-                        params: { width: w, depth: l, height: h, at: [x, y, z], centered: false },
-                    }],
-            };
-        }
-        case 'Part::Cylinder': {
-            const r = propNum(obj, 'Radius') ?? 0;
-            const h = propNum(obj, 'Height') ?? 0;
-            const [x, y, z] = placementPos(obj);
-            const angle = propNum(obj, 'Angle') ?? 360;
-            if (angle !== 360)
-                return { kind: 'baked', reason: 'cylinder-partial-angle' };
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.cylinder', source: obj.name, inputs: [],
-                        params: { radius: r, height: h, at: [x, y, z], centered: false },
-                    }],
-            };
-        }
-        case 'Part::Compound': {
-            // M13.1 probe (ArchDetail.FCStd): members live in a `Links`
-            // PropertyLinkList; every corpus instance also stores a baked .brp,
-            // but translating the member group keeps the chain explicit.
-            const linksEl = obj.properties.get('Links')?.children[0];
-            const members = [];
-            for (const link of linksEl?.children ?? []) {
-                const v = link.attributes['value'];
-                if (v)
-                    members.push(v);
-            }
-            const vars = members.map((m) => inputVar(m));
-            if (vars.length === 0 || vars.some((v) => v === undefined)) {
-                return { kind: 'baked', reason: 'compound-missing-members' };
-            }
-            // `Part::Compound` 是几何对象（`Part::Feature` 子类，带 Shape + Placement）。
-            // 用平台几何 compound（`cad.compound`，内核 `makeCompound`，持 OCCT 句柄，
-            // 可变换/可导出），不再借用 ../3d_editor 的结构分组 op `cad.group`。
-            // members 经 `params.members` 传递；`inputs` 仅作依赖登记（consumed / 变量重映射），
-            // 由 `noPositionalArgs` 保证不被 renderArgs 当作位置参数渲染。
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.compound', source: obj.name, inputs: vars,
-                        noPositionalArgs: true, params: { members: vars },
-                    }],
-            };
-        }
-        case 'Part::Sphere': {
-            const r = propNum(obj, 'Radius');
-            if (r === undefined || r <= 0)
-                return { kind: 'baked', reason: 'sphere-missing-radius' };
-            const angle1 = propNum(obj, 'Angle1') ?? -90;
-            const angle2 = propNum(obj, 'Angle2') ?? 90;
-            const angle3 = propNum(obj, 'Angle3') ?? 360;
-            if (angle1 !== -90 || angle2 !== 90 || angle3 !== 360) {
-                return { kind: 'baked', reason: 'sphere-partial-angle' };
-            }
-            const [x, y, z] = placementPos(obj);
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.sphere', source: obj.name, inputs: [],
-                        params: { radius: r, at: [x, y, z] },
-                    }],
-            };
-        }
-        case 'Part::Cut': {
-            const base = propLink(obj, 'Base');
-            const tool = propLink(obj, 'Tool');
-            const b = base ? inputVar(base) : undefined;
-            const t = tool ? inputVar(tool) : undefined;
-            if (!b || !t)
-                return { kind: 'baked', reason: 'cut-missing-dependency' };
-            return {
-                kind: 'translated',
-                calls: [{ out, op: 'cad.subtract', source: obj.name, inputs: [b, t], params: {} }],
-            };
-        }
-        case 'Part::MultiFuse': {
-            // <LinkList count="N"><Link value="A"/>...</LinkList>
-            const shapes = propLinkList(obj, 'Shapes');
-            const inputs = shapes.map(inputVar);
-            if (shapes.length < 2 || inputs.some((i) => i === undefined)) {
-                return { kind: 'baked', reason: 'multifuse-missing-dependency' };
-            }
-            return {
-                kind: 'translated',
-                calls: [{ out, op: 'cad.union', source: obj.name, inputs: inputs, params: {} }],
-            };
-        }
-        case 'PartDesign::Pad': {
-            const profile = profileLink(obj);
-            const len = propNum(obj, 'Length') ?? 0;
-            const reversed = propBool(obj, 'Reversed');
-            const midplane = propBool(obj, 'Midplane');
-            const profileVar = profile ? inputVar(profile) : undefined;
-            if (!profileVar)
-                return { kind: 'baked', reason: 'pad-missing-profile' };
-            // M11.2: a non-constant expression binding (cross-object reference /
-            // identifier arithmetic) leaves the length unknown — explicit bake,
-            // never estimate (plan §12).
-            if (hasNonConstantBinding(obj, 'Length')) {
-                return { kind: 'baked', reason: 'pad-length-expression-non-constant' };
-            }
-            // M9.1/M9.2: Type-driven semantics — no silent Length fallback.
-            const ftype = featureTypeOf(obj, 'pad');
-            if (ftype === 'TwoLengths') {
-                const len2 = propNum(obj, 'Length2') ?? 0;
-                // TwoLengths: Length forward + Length2 backward, fused. Named
-                // intermediate vars so mapping/debug can locate each segment.
-                const pos = `${out}__pos`;
-                const neg = `${out}__neg`;
-                const calls = [
-                    { out: pos, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, len]], params: {} },
-                    { out: neg, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, -len2]], params: {} },
-                    { out, op: 'cad.union', source: obj.name, inputs: [pos, neg], params: {} },
-                ];
-                return { kind: 'translated', calls };
-            }
-            if (ftype === 'UpToFace') {
-                // extrude-upto-face plan §4.3-C1: when the target is a datum plane
-                // (PartDesign::Plane — an infinite plane, not a solid face), the
-                // extrude length is the exact signed distance from the profile plane
-                // to the datum plane. Zero bake, no faceRef needed.
-                const upTo = propLinkSub(obj, 'UpToFace');
-                if (upTo && docObjects) {
-                    const target = docObjects.find((o) => o.name === upTo.obj);
-                    // C1 (extrude-upto-face §4.3-C1): datum plane (infinite plane) →
-                    // exact signed distance → cad.extrude({ length }). No faceRef needed.
-                    if (target && target.type === 'PartDesign::Plane') {
-                        const pl = placementOf(target);
-                        // datum plane normal = placement R * local +Z
-                        const m = quatToMatrix(pl.q);
-                        const normal = [m[2], m[5], m[8]];
-                        // sketch normal (the extrude direction); the profile sketch lies on
-                        // its own placement, and the feature extrudes along it.
-                        const skPl = placementOf(docObjects.find((o) => o.name === (profile ?? '')) ?? target);
-                        const skM = quatToMatrix(skPl.q);
-                        const dir = [skM[2], skM[5], skM[8]];
-                        // GOTCHA (probe-upto-padtest-verify.ts, PadTest Pad001): the datum
-                        // plane is an arbitrary plane, NOT axis-aligned to the extrude
-                        // direction. The signed distance to reach it along `dir` is
-                        //   t = ((pl.p - skPl.p) · n) / (dir · n)
-                        // where n is the datum plane normal — NOT the naive (Δp · dir),
-                        // which only works when n ∥ dir (axis-aligned). The naive form
-                        // yields −50 for PadTest while the true distance is +10; the
-                        // corrected form matches FreeCAD's Tip bbox exactly (diag 156.84).
-                        const denom = dir[0] * normal[0] + dir[1] * normal[1] + dir[2] * normal[2];
-                        // plane parallel to the extrude direction → no finite intersection
-                        if (!Number.isFinite(denom) || Math.abs(denom) < 1e-9) {
-                            return { kind: 'baked', reason: 'uptoface-datum-plane-parallel' };
-                        }
-                        const dpn = (pl.p[0] - skPl.p[0]) * normal[0] +
-                            (pl.p[1] - skPl.p[1]) * normal[1] +
-                            (pl.p[2] - skPl.p[2]) * normal[2];
-                        const t = dpn / denom;
-                        if (Number.isFinite(t) && Math.abs(t) > 1e-9) {
-                            // GOTCHA (PadTest V6 residual, relErr 3.02%): the datum plane may
-                            // be TILTED relative to the extrude direction (Pad001: datum
-                            // normal (−0.038·…) not parallel to the sketch normal). A fixed
-                            // length `signed` gives a FLAT top; FreeCAD's Pad reaches the
-                            // PLANE, producing a slanted top (truth AddShape 4860.42 vs flat
-                            // disc 1874.83). Emit an explicit plane target instead and let
-                            // the kernel's half-space intersection produce the slanted cut.
-                            // The extrude runs in sketch-local coords, so transform the
-                            // global plane into the sketch frame: p_local = R⁻¹(p_g − sk.p),
-                            // n_local = R⁻¹(n_g) (R⁻¹ = Rᵀ).
-                            const inv = [0, 1, 2].map((c) => [
-                                skM[c], skM[3 + c], skM[6 + c],
-                            ]);
-                            const d = [
-                                pl.p[0] - skPl.p[0], pl.p[1] - skPl.p[1], pl.p[2] - skPl.p[2],
-                            ];
-                            const ptLocal = [
-                                inv[0][0] * d[0] + inv[0][1] * d[1] + inv[0][2] * d[2],
-                                inv[1][0] * d[0] + inv[1][1] * d[1] + inv[1][2] * d[2],
-                                inv[2][0] * d[0] + inv[2][1] * d[1] + inv[2][2] * d[2],
-                            ];
-                            const nLocal = [
-                                inv[0][0] * normal[0] + inv[0][1] * normal[1] + inv[0][2] * normal[2],
-                                inv[1][0] * normal[0] + inv[1][1] * normal[1] + inv[1][2] * normal[2],
-                                inv[2][0] * normal[0] + inv[2][1] * normal[1] + inv[2][2] * normal[2],
-                            ];
-                            return {
-                                kind: 'translated',
-                                reason: 'uptoface-via-datum-plane-distance',
-                                calls: [{
-                                        out, op: 'cad.extrude', source: obj.name, inputs: [profileVar],
-                                        params: { upTo: { plane: { point: ptLocal, normal: nLocal } } },
-                                    }],
-                            };
-                        }
-                        return { kind: 'baked', reason: 'uptoface-datum-plane-degenerate-distance' };
-                    }
-                    // C2.2 (extrude-upto-face §4.3-C2 point 2): solid-feature target →
-                    // reference its face by ordinal via `cad.extrude({ upTo:
-                    // cad.faceRef(targetVar, N) })`. faceRef's ordinal is calibrated to
-                    // match FreeCAD's `FaceN` (R-A, same TopExp::MapShapes + IndexedMap
-                    // enumeration as edgeRef); the runtime naming layer resolves the ref
-                    // against the live target shape, so it enters the IR as a JsExpr.
-                    if (target) {
-                        const targetVar = inputVar(upTo.obj);
-                        if (targetVar) {
-                            const faceN = parseFaceSub(upTo.subs);
-                            if (faceN !== undefined) {
-                                return {
-                                    kind: 'translated',
-                                    reason: 'uptoface-via-faceRef',
-                                    calls: [{
-                                            out, op: 'cad.extrude', source: obj.name, inputs: [profileVar],
-                                            params: { upTo: jsExpr(`cad.faceRef(${targetVar}, ${faceN})`) },
-                                        }],
-                                };
-                            }
-                            // sub present but not a plain FaceN reference → explicit bake
-                            return { kind: 'baked', reason: 'uptoface-sub-unparseable' };
-                        }
-                    }
-                }
-                return { kind: 'baked', reason: 'uptoface-solid-face-unsupported' };
-            }
-            if (ftype === 'UpToLast' || ftype === 'UpToFirst') {
-                // plan §4.3-C2: UpToLast/UpToFirst extrude to the far/near face of the
-                // support (BaseFeature) via `cad.extrude({ upTo: 'last' | 'first' })`
-                // (up-to lives on the platform op cad.extrude, never on fai_extrude).
-                // The kernel up-to does the truncation; baseFeature must be resolvable
-                // or we bake explicitly — no silent bbox-derived length guess.
-                const base = propLink(obj, 'BaseFeature');
-                const baseVar = base ? inputVar(base) : undefined;
-                if (!baseVar)
-                    return { kind: 'baked', reason: 'pad-upTo-missing-base' };
-                const upTo = ftype === 'UpToLast' ? 'last' : 'first';
-                return {
-                    kind: 'translated',
-                    reason: `pad-${ftype}-via-baseFeature`,
-                    calls: [{
-                            out, op: 'cad.extrude', source: obj.name, inputs: [profileVar],
-                            params: { upTo, baseFeature: jsExpr(baseVar) },
-                        }],
-                };
-            }
-            if (ftype !== 'Length') {
-                // anything still non-Length (e.g. 'unknown') → explicit bake, never guess
-                return { kind: 'baked', reason: `pad-type-${ftype}-unsupported` };
-            }
-            // cad.extrude extrudes the sketch face into a prism along +Z (the sketch
-            // normal in body-local frame); length sign encodes direction.
-            if (midplane) {
-                // symmetric about the sketch plane: two half-prisms fused
-                const pos = `${out}__pos`;
-                const neg = `${out}__neg`;
-                const calls = [
-                    { out: pos, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, len / 2]], params: {} },
-                    { out: neg, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, -len / 2]], params: {} },
-                    { out, op: 'cad.union', source: obj.name, inputs: [pos, neg], params: {} },
-                ];
-                return { kind: 'translated', calls };
-            }
-            const signed = reversed ? -len : len;
-            return {
-                kind: 'translated',
-                calls: [{ out, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, signed]], params: {} }],
-            };
-        }
-        case 'PartDesign::Pocket': {
-            const profile = profileLink(obj);
-            const len = propNum(obj, 'Length') ?? 0;
-            const reversed = propBool(obj, 'Reversed');
-            const midplane = propBool(obj, 'Midplane');
-            const base = propLink(obj, 'BaseFeature');
-            const profileVar = profile ? inputVar(profile) : undefined;
-            // GOTCHA (hole_puzzle corpus, 2026-09-20): FreeCAD 0.20+ PartDesign
-            // files routinely OMIT BaseFeature on interior features — the base is
-            // implied by the Body's feature order (chain head). A MISSING property
-            // is "no explicit base" → emit the subtract with the BODY_CHAIN_BASE
-            // marker; codegen retargets it at the chain head when folding. Only an
-            // EXPLICIT base that fails to resolve is a dependency gap.
-            const baseVar = base ? inputVar(base) : BODY_CHAIN_BASE;
-            if (!profileVar || !baseVar)
-                return { kind: 'baked', reason: 'pocket-missing-dependency' };
-            if (hasNonConstantBinding(obj, 'Length')) {
-                return { kind: 'baked', reason: 'pocket-length-expression-non-constant' };
-            }
-            // M9.1/M9.2/M9.3: Type-driven semantics — explicit bake for anything
-            // beyond the supported set (no silent downgrade).
-            const ftype = featureTypeOf(obj, 'pocket');
-            if (ftype === 'UpToFace') {
-                // C2.3 (extrude-upto-face §4.3-C2 point 4): Pocket UpToFace — same
-                // datum-plane path as Pad (plane target in sketch-local frame); the
-                // cut direction is handled by the kernel's auto-orientation toward
-                // the plane (GOTCHA: Pocket cuts INTO the material, the plane lies
-                // on the far side, and the kernel flips the extrude direction).
-                const upTo = propLinkSub(obj, 'UpToFace');
-                if (upTo && docObjects) {
-                    const target = docObjects.find((o) => o.name === upTo.obj);
-                    if (target && target.type === 'PartDesign::Plane') {
-                        const pl = placementOf(target);
-                        const m = quatToMatrix(pl.q);
-                        const normal = [m[2], m[5], m[8]];
-                        const skPl = placementOf(docObjects.find((o) => o.name === (profile ?? '')) ?? target);
-                        const skM = quatToMatrix(skPl.q);
-                        const dir = [skM[2], skM[5], skM[8]];
-                        const denom = dir[0] * normal[0] + dir[1] * normal[1] + dir[2] * normal[2];
-                        if (!Number.isFinite(denom) || Math.abs(denom) < 1e-9) {
-                            return { kind: 'baked', reason: 'pocket-uptoface-datum-plane-parallel' };
-                        }
-                        // plane → sketch-local frame (p_local = R⁻¹(p_g − sk.p), n_local = R⁻¹ n)
-                        const inv = [0, 1, 2].map((c) => [skM[c], skM[3 + c], skM[6 + c]]);
-                        const d = [pl.p[0] - skPl.p[0], pl.p[1] - skPl.p[1], pl.p[2] - skPl.p[2]];
-                        const ptLocal = [
-                            inv[0][0] * d[0] + inv[0][1] * d[1] + inv[0][2] * d[2],
-                            inv[1][0] * d[0] + inv[1][1] * d[1] + inv[1][2] * d[2],
-                            inv[2][0] * d[0] + inv[2][1] * d[1] + inv[2][2] * d[2],
-                        ];
-                        const nLocal = [
-                            inv[0][0] * normal[0] + inv[0][1] * normal[1] + inv[0][2] * normal[2],
-                            inv[1][0] * normal[0] + inv[1][1] * normal[1] + inv[1][2] * normal[2],
-                            inv[2][0] * normal[0] + inv[2][1] * normal[1] + inv[2][2] * normal[2],
-                        ];
-                        const cutVar = `${out}_cut`;
-                        const calls = [
-                            {
-                                out: cutVar, op: 'cad.extrude', source: obj.name, inputs: [profileVar],
-                                params: { upTo: { plane: { point: ptLocal, normal: nLocal } } },
-                            },
-                            { out, op: 'cad.subtract', source: obj.name, inputs: [baseVar, cutVar], params: {} },
-                        ];
-                        return { kind: 'translated', reason: 'pocket-uptoface-via-datum-plane', calls };
-                    }
-                    return { kind: 'baked', reason: 'pocket-uptoface-solid-face-unsupported' };
-                }
-                return { kind: 'baked', reason: 'pocket-uptoface-sub-unparseable' };
-            }
-            if (ftype === 'UpToFirst') {
-                // C2.3: Pocket UpToFirst — cut prism to the support's NEAR face along
-                // the cut direction; the kernel truncates the prism against the
-                // baseFeature (chain head), then the result is subtracted.
-                const baseVarUp = baseVar;
-                const cutVar = `${out}_cut`;
-                const calls = [
-                    {
-                        out: cutVar, op: 'cad.extrude', source: obj.name, inputs: [profileVar],
-                        params: { upTo: 'first', baseFeature: jsExpr(baseVarUp) },
-                    },
-                    { out, op: 'cad.subtract', source: obj.name, inputs: [baseVarUp, cutVar], params: {} },
-                ];
-                return { kind: 'translated', reason: 'pocket-uptofirst-via-baseFeature', calls };
-            }
-            if (ftype !== 'Length' && ftype !== 'TwoLengths' && ftype !== 'ThroughAll') {
-                return { kind: 'baked', reason: `pocket-type-${ftype}-unsupported` };
-            }
-            if (midplane)
-                return { kind: 'baked', reason: 'pocket-midplane-unsupported' };
-            // Pocket cuts INTO the material: extrude the profile opposite the normal
-            // (or along it when Reversed), then subtract from base.
-            // ThroughAll (hole_puzzle corpus, 2026-09-20): FreeCAD truncates the
-            // prism against the base solid, so a depth far beyond any realistic
-            // base extent is safe — the subtract is exact either way.
-            const THROUGH_ALL_DEPTH = 1e6;
-            const depth = ftype === 'ThroughAll' ? THROUGH_ALL_DEPTH : len;
-            const signed = reversed ? depth : -depth;
-            const cutVar = `${out}_cut`;
-            const calls = [{
-                    out: cutVar, op: 'cad.extrude', source: obj.name, inputs: [profileVar], literals: [[0, 0, signed]], params: {},
-                }];
-            calls.push({ out, op: 'cad.subtract', source: obj.name, inputs: [baseVar, cutVar], params: {} });
-            return { kind: 'translated', calls };
-        }
-        case 'Part::Extrusion': {
-            const base = propLink(obj, 'Base');
-            const baseVar = base ? inputVar(base) : undefined;
-            if (!baseVar)
-                return { kind: 'baked', reason: 'extrusion-missing-base' };
-            const len = propNum(obj, 'Length') ?? 0;
-            const dir = propVec(obj, 'Dir') ?? [0, 0, 1];
-            const reversed = propBool(obj, 'Reverse');
-            const vec = [dir[0] * len, dir[1] * len, dir[2] * len];
-            const s = reversed ? -1 : 1;
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.extrude', source: obj.name, inputs: [baseVar],
-                        literals: [[s * vec[0], s * vec[1], s * vec[2]]], params: {},
-                    }],
-            };
-        }
-        case 'PartDesign::Revolution': {
-            const profile = profileLink(obj);
-            const profileVar = profile ? inputVar(profile) : undefined;
-            if (!profileVar)
-                return { kind: 'baked', reason: 'revolution-missing-profile' };
-            const angleDeg = propNum(obj, 'Angle') ?? 360;
-            const angle = (angleDeg * Math.PI) / 180;
-            const axisInfo = parseReferenceAxis(propStr(obj, 'ReferenceAxis'));
-            if (!axisInfo)
-                return { kind: 'baked', reason: 'revolution-edge-axis-unsupported' };
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.revolve', source: obj.name, inputs: [profileVar],
-                        params: { axis: axisInfo.axis, at: axisInfo.at, angle },
-                    }],
-            };
-        }
-        case 'PartDesign::LinearPattern': {
-            const source = propLink(obj, 'Source');
-            const sourceVar = source ? inputVar(source) : undefined;
-            if (!sourceVar)
-                return { kind: 'baked', reason: 'linear-pattern-missing-source' };
-            const dirInfo = parseReferenceAxis(propStr(obj, 'Direction'));
-            if (!dirInfo)
-                return { kind: 'baked', reason: 'linear-pattern-edge-dir-unsupported' };
-            const occ = Math.max(2, Math.round(propNum(obj, 'Occurrences') ?? 2));
-            const length = propNum(obj, 'Length') ?? 0;
-            const spacing = occ > 1 ? length / (occ - 1) : 0;
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.linearPattern', source: obj.name, inputs: [sourceVar],
-                        literals: [dirInfo.axis, occ, spacing], params: {},
-                    }],
-            };
-        }
-        case 'PartDesign::PolarPattern': {
-            const source = propLink(obj, 'Source');
-            const sourceVar = source ? inputVar(source) : undefined;
-            if (!sourceVar)
-                return { kind: 'baked', reason: 'polar-pattern-missing-source' };
-            const axisInfo = parseReferenceAxis(propStr(obj, 'Axis'));
-            if (!axisInfo)
-                return { kind: 'baked', reason: 'polar-pattern-edge-axis-unsupported' };
-            const occ = Math.max(2, Math.round(propNum(obj, 'Occurrences') ?? 2));
-            const angle = propNum(obj, 'Angle') ?? 360;
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.circularPattern', source: obj.name, inputs: [sourceVar],
-                        literals: [axisInfo.axis, occ, angle], params: {},
-                    }],
-            };
-        }
-        case 'PartDesign::Fillet': {
-            const base = propLinkSub(obj, 'Base');
-            const baseVar = base ? inputVar(base.obj) : undefined;
-            if (!baseVar)
-                return { kind: 'baked', reason: 'fillet-missing-base' };
-            if (propBool(obj, 'UseAllEdges'))
-                return { kind: 'baked', reason: 'fillet-all-edges-unsupported' };
-            if (!base || base.subs.length === 0)
-                return { kind: 'baked', reason: 'fillet-no-edges' };
-            const ordinals = parseEdgeSubs(base.subs);
-            if (!ordinals)
-                return { kind: 'baked', reason: 'fillet-non-edge-sub' };
-            const radius = propNum(obj, 'Radius');
-            if (radius === undefined || !(radius > 0))
-                return { kind: 'baked', reason: 'fillet-bad-radius' };
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.fillet', source: obj.name, inputs: [baseVar],
-                        params: { edges: edgeRefArgs(baseVar, ordinals), radius },
-                    }],
-            };
-        }
-        case 'PartDesign::Chamfer': {
-            const base = propLinkSub(obj, 'Base');
-            const baseVar = base ? inputVar(base.obj) : undefined;
-            if (!baseVar)
-                return { kind: 'baked', reason: 'chamfer-missing-base' };
-            if (propBool(obj, 'UseAllEdges'))
-                return { kind: 'baked', reason: 'chamfer-all-edges-unsupported' };
-            if (!base || base.subs.length === 0)
-                return { kind: 'baked', reason: 'chamfer-no-edges' };
-            const ordinals = parseEdgeSubs(base.subs);
-            if (!ordinals)
-                return { kind: 'baked', reason: 'chamfer-non-edge-sub' };
-            const edges = edgeRefArgs(baseVar, ordinals);
-            // ChamferType enum (FeatureChamfer.cpp:55): 0 "Equal distance" (the
-            // default when the property is absent, i.e. files predating it),
-            // 1 "Two distances", 2 "Distance and Angle".
-            const type = Math.round(propNum(obj, 'ChamferType') ?? 0);
-            const size = propNum(obj, 'Size');
-            if (type === 1) {
-                const size2 = propNum(obj, 'Size2');
-                if (size === undefined || !(size > 0) || size2 === undefined || !(size2 > 0)) {
-                    return { kind: 'baked', reason: 'chamfer-bad-two-distances' };
-                }
-                return {
-                    kind: 'translated',
-                    calls: [{
-                            out, op: 'cad.chamfer', source: obj.name, inputs: [baseVar],
-                            params: { edges, type: 'twoDistances', width1: size, width2: size2 },
-                        }],
-                };
-            }
-            if (type === 2) {
-                // FreeCAD's Angle is degrees, range 0–180 (floatAngle); cad.chamfer
-                // accepts degrees in the open interval (0, 90) only.
-                const angle = propNum(obj, 'Angle');
-                if (size === undefined || !(size > 0) || angle === undefined || !(angle > 0 && angle < 90)) {
-                    return { kind: 'baked', reason: 'chamfer-bad-distance-angle' };
-                }
-                return {
-                    kind: 'translated',
-                    calls: [{
-                            out, op: 'cad.chamfer', source: obj.name, inputs: [baseVar],
-                            params: { edges, type: 'distanceAngle', width: size, angle },
-                        }],
-                };
-            }
-            if (type !== 0)
-                return { kind: 'baked', reason: `chamfer-unknown-type: ${type}` };
-            if (size === undefined || !(size > 0))
-                return { kind: 'baked', reason: 'chamfer-bad-size' };
-            return {
-                kind: 'translated',
-                calls: [{
-                        out, op: 'cad.chamfer', source: obj.name, inputs: [baseVar],
-                        params: { edges, type: 'equal', width: size },
-                    }],
-            };
-        }
-        default:
-            return { kind: 'baked', reason: `type-not-implemented: ${obj.type}` };
-    }
-}
-function propLinkList(obj, name) {
-    const listEl = obj.properties.get(name)?.children[0];
-    if (!listEl)
-        return [];
-    const out = [];
-    for (const link of listEl.children) {
-        const v = link.attributes['value'];
-        if (v)
-            out.push(v);
-    }
-    return out;
-}
-//# sourceMappingURL=feature-translate.js.map