@faicad/faijs 0.14.1 → 0.16.0

package/dist/lang/parser.js

@@ -1,1594 +0,0 @@
-/**
- * parser — 文本 → ScriptIR（合法 JS 子集，设计文档 §2）
- *
- * 执行模型：`.fai.js` 文本先用 acorn 解析（合法性证明 J-1），再 walk AST 还原为 ScriptIR。
- * 绝不 eval / new Function / import() 真执行。
- *
- * 支持的语法（合法 JS 子集）：
- * - `// apiVersion: N` — 版本声明（可选，默认 1）
- * - `export default async (cad) => { ... }` — 唯一合法容器
- * - `const <name> = <literal>` → ParamDef（参数声明，右侧仅字面量）
- * - `const part<N>_v<M> = [await] cad.<op>(<inputVar>?, { ...args })` → StatementIR
- * - `cad.union/subtract/intersect(inputVar, inputVar)` → boolean op
- * - `cad.faceNormal(var)` / `cad.bboxCenter(var)` / ... → GeomRef
- * - `return { shape: part<N>_v<M>, name, color, metalness, roughness }` → ScriptIR.meta
- *
- * 禁止（acorn 抛错或 AST walk 拒绝即 ParseError）：
- * - `param` / `with` 关键字、对象字面量用 `=`
- * - 循环 / 条件 / IIFE / try-catch / 模板字符串
- * - 多 default export、函数定义（除顶层箭头外）
- * - eval / new Function / 动态 import()
- */
-import { parse as acornParse } from 'acorn';
-import { isParamRef, isVarRef, isCallRef, isExprRef, splitPositionalOptions } from './types.js';
-import { asStmtId, asPartName, } from '../identity.js';
-// ── 解析错误 ──
-// ParseError / ParseErrorCode 的唯一家在 parse-error.ts（无 IR 方案下 MetadataExtractor
-// / SyntaxGate 复用同一类；此处重导出保持历史 import 面兼容）。
-import { ParseError } from './parse-error.js';
-import { fnv1a32 } from './fnv-hash.js';
-export { ParseError } from './parse-error.js';
-function getLine(node) {
-    return node?.loc?.start?.line ?? 0;
-}
-/** 数值折叠：非有限值（NaN/Infinity）不是 JSON 安全字面量 → 不可折叠。 */
-function numFold(v, usedParam = false) {
-    return Number.isFinite(v) ? { ok: true, value: v, usedParam } : { ok: false };
-}
-function numBin(a, b, op, usedParam = false) {
-    return typeof a === 'number' && typeof b === 'number' ? numFold(op(a, b), usedParam) : { ok: false };
-}
-function cmpBin(a, b, op, usedParam = false) {
-    if (typeof a === 'number' && typeof b === 'number')
-        return { ok: true, value: op(a, b), usedParam };
-    if (typeof a === 'string' && typeof b === 'string')
-        return { ok: true, value: op(a, b), usedParam };
-    return { ok: false };
-}
-/** JS `==` 的 JSON 值域近似（null/boolean/number/string，无对象）。 */
-function looseEq(a, b) {
-    let x = a;
-    let y = b;
-    if (typeof x === 'boolean')
-        x = x ? 1 : 0;
-    if (typeof y === 'boolean')
-        y = y ? 1 : 0;
-    if (typeof x === 'number' && typeof y === 'string')
-        return x === Number(y);
-    if (typeof x === 'string' && typeof y === 'number')
-        return Number(x) === y;
-    if (x === null || y === null)
-        return x === null && y === null;
-    return x === y;
-}
-/**
- * 静态折叠求值：仅接受可由「字面量 + 参数值」算出的表达式。
- * 引用语句变量 / 嵌套调用 / 成员访问 → 不可折叠（返回 ok:false，调用方报 E_VALUE）。
- */
-function tryFoldConstExpr(node, paramNames, paramValues) {
-    switch (node.type) {
-        case 'Literal':
-            return { ok: true, value: node.value, usedParam: false };
-        case 'Identifier': {
-            if (!paramNames.has(node.name))
-                return { ok: false };
-            const v = paramValues.get(node.name);
-            return v === undefined ? { ok: false } : { ok: true, value: v, usedParam: true };
-        }
-        case 'UnaryExpression': {
-            const operand = tryFoldConstExpr(node.argument, paramNames, paramValues);
-            if (!operand.ok)
-                return { ok: false };
-            const v = operand.value;
-            switch (node.operator) {
-                case '-': return typeof v === 'number' ? numFold(-v, operand.usedParam) : { ok: false };
-                case '+': return typeof v === 'number' ? numFold(+v, operand.usedParam) : { ok: false };
-                case '!': return { ok: true, value: !v, usedParam: operand.usedParam };
-                case '~': return typeof v === 'number' ? { ok: true, value: ~v, usedParam: operand.usedParam } : { ok: false };
-                case 'typeof': return { ok: true, value: typeof v, usedParam: operand.usedParam };
-                default: return { ok: false };
-            }
-        }
-        case 'BinaryExpression': {
-            const left = tryFoldConstExpr(node.left, paramNames, paramValues);
-            if (!left.ok)
-                return { ok: false };
-            const right = tryFoldConstExpr(node.right, paramNames, paramValues);
-            if (!right.ok)
-                return { ok: false };
-            const a = left.value;
-            const b = right.value;
-            const usedParam = left.usedParam || right.usedParam;
-            switch (node.operator) {
-                case '+': {
-                    if (typeof a === 'number' && typeof b === 'number')
-                        return numFold(a + b, usedParam);
-                    if (typeof a === 'string' || typeof b === 'string')
-                        return { ok: true, value: String(a) + String(b), usedParam };
-                    return { ok: false };
-                }
-                case '-': return numBin(a, b, (x, y) => x - y, usedParam);
-                case '*': return numBin(a, b, (x, y) => x * y, usedParam);
-                case '/': return numBin(a, b, (x, y) => x / y, usedParam);
-                case '%': return numBin(a, b, (x, y) => x % y, usedParam);
-                case '**': return numBin(a, b, (x, y) => x ** y, usedParam);
-                case '<': return cmpBin(a, b, (x, y) => x < y, usedParam);
-                case '<=': return cmpBin(a, b, (x, y) => x <= y, usedParam);
-                case '>': return cmpBin(a, b, (x, y) => x > y, usedParam);
-                case '>=': return cmpBin(a, b, (x, y) => x >= y, usedParam);
-                case '==': return { ok: true, value: looseEq(a, b), usedParam };
-                case '!=': return { ok: true, value: !looseEq(a, b), usedParam };
-                case '===': return { ok: true, value: a === b, usedParam };
-                case '!==': return { ok: true, value: a !== b, usedParam };
-                default: return { ok: false };
-            }
-        }
-        // acorn 把 && / || / ?? 解析为 LogicalExpression（ESTree 规范）
-        case 'LogicalExpression': {
-            const left = tryFoldConstExpr(node.left, paramNames, paramValues);
-            if (!left.ok)
-                return { ok: false };
-            const right = tryFoldConstExpr(node.right, paramNames, paramValues);
-            if (!right.ok)
-                return { ok: false };
-            const a = left.value;
-            const usedParam = left.usedParam || right.usedParam;
-            switch (node.operator) {
-                case '&&': return { ok: true, value: a ? right.value : left.value, usedParam };
-                case '||': return { ok: true, value: a ? left.value : right.value, usedParam };
-                case '??': return { ok: true, value: a === null ? right.value : left.value, usedParam };
-                default: return { ok: false };
-            }
-        }
-        case 'TemplateLiteral': {
-            const parts = [];
-            const quasis = node.quasis;
-            const exprs = node.expressions;
-            let usedParam = false;
-            for (let i = 0; i < quasis.length; i++) {
-                const cooked = quasis[i].value?.cooked;
-                parts.push(cooked ?? '');
-                if (i < exprs.length) {
-                    const r = tryFoldConstExpr(exprs[i], paramNames, paramValues);
-                    if (!r.ok)
-                        return { ok: false };
-                    usedParam = usedParam || r.usedParam;
-                    parts.push(String(r.value));
-                }
-            }
-            return { ok: true, value: parts.join(''), usedParam };
-        }
-        case 'ConditionalExpression': {
-            const test = tryFoldConstExpr(node.test, paramNames, paramValues);
-            if (!test.ok)
-                return { ok: false };
-            const chosen = tryFoldConstExpr(test.value ? node.consequent : node.alternate, paramNames, paramValues);
-            if (!chosen.ok)
-                return { ok: false };
-            return { ok: true, value: chosen.value, usedParam: test.usedParam || chosen.usedParam };
-        }
-        default:
-            return { ok: false };
-    }
-}
-// ── ExprIR（运行时表达式，控制流放松方案 §3.3 / §4.3） ──
-// 折叠失败（引用了语句变量等）且节点 ∈ 白名单文法时，把表达式原文 + 引用名
-// 集合降级为 ExprIR，由编译期箭头包装发射、JS 引擎运行时求值（§5.4）。
-/**
- * ExprIR 白名单文法（§3.3，true-JS-subset 方案 D2 扩展）：Literal / Identifier /
- * Unary / Binary / Logical / Conditional / Array（元素递归走白名单）/
- * **MemberExpression**（非可选链的全形态，computed 与否均收）/
- * **CallExpression**（方法调用 `a.b(c)` 归入 ExprIR；命名空间根调用在调用方
- * 先被截为 CallRefIR，不会到达此处）。
- *
- * ObjectExpression 不整体降级：对象属性值引用变量时本就是 VarRefIR（现状路径），
- * 属性值为折叠失败的表达式时由属性值递归各自降级为 ExprIR——整体降级语义等价
- * 且会误伤 args 顶层容器（`cad.op({ size: ... })` 的整个 args 对象不能被降级）。
- *
- * 命名空间限制（§4.2.2）：ExprIR 文本由箭头包装在语句 fn 体内求值，命名空间
- * 绑定名（cad / import 绑定名）在该作用域不可见——含命名空间根调用的复合表达式
- * 由调用方（containsNsRootedCall 守卫）显式报 E_VALUE，不会进入 ExprIR。
- */
-function isExprWhitelist(node) {
-    if (!node || typeof node !== 'object')
-        return false;
-    switch (node.type) {
-        case 'Literal':
-        case 'Identifier':
-            return true;
-        case 'UnaryExpression':
-            return isExprWhitelist(node.argument);
-        case 'BinaryExpression':
-        case 'LogicalExpression':
-            return isExprWhitelist(node.left) && isExprWhitelist(node.right);
-        case 'ConditionalExpression':
-            return (isExprWhitelist(node.test) &&
-                isExprWhitelist(node.consequent) &&
-                isExprWhitelist(node.alternate));
-        case 'ArrayExpression':
-            return node.elements.every((el) => el !== null && el !== undefined && isExprWhitelist(el));
-        case 'MemberExpression':
-            // 可选链（a?.b / a?.[b]）不在子集内
-            if (node.optional)
-                return false;
-            if (!isExprWhitelist(node.object))
-                return false;
-            return node.computed ? isExprWhitelist(node.property) : true;
-        case 'CallExpression': {
-            if (node.optional)
-                return false;
-            if (!isExprWhitelist(node.callee))
-                return false;
-            return node.arguments.every((a) => a.type !== 'SpreadElement' && isExprWhitelist(a));
-        }
-        default:
-            return false;
-    }
-}
-/**
- * 守卫：表达式树中是否含「命名空间根调用」（callee 链根标识符 ∈ nsNames 的
- * CallExpression）。这类子表达式无法在语句 fn 体的箭头包装作用域内解析
- * （命名空间经 ns.<name> 访问，非词法绑定）→ 调用方显式报 E_VALUE；
- * 整体作为单个实参的命名空间调用仍走 CallRefIR（现状路径，不受影响）。
- */
-function containsNsRootedCall(node, nsNames) {
-    if (!node || typeof node !== 'object')
-        return false;
-    switch (node.type) {
-        case 'CallExpression': {
-            const root = rootIdentifierOfCallee(node.callee);
-            if (root !== null && nsNames.has(root))
-                return true;
-            if (containsNsRootedCall(node.callee, nsNames))
-                return true;
-            return node.arguments.some((a) => containsNsRootedCall(a, nsNames));
-        }
-        case 'MemberExpression':
-            return containsNsRootedCall(node.object, nsNames) ||
-                (node.computed ? containsNsRootedCall(node.property, nsNames) : false);
-        case 'UnaryExpression':
-            return containsNsRootedCall(node.argument, nsNames);
-        case 'BinaryExpression':
-        case 'LogicalExpression':
-            return containsNsRootedCall(node.left, nsNames) || containsNsRootedCall(node.right, nsNames);
-        case 'ConditionalExpression':
-            return (containsNsRootedCall(node.test, nsNames) ||
-                containsNsRootedCall(node.consequent, nsNames) ||
-                containsNsRootedCall(node.alternate, nsNames));
-        case 'ArrayExpression':
-            return node.elements.some((el) => containsNsRootedCall(el, nsNames));
-        default:
-            return false;
-    }
-}
-/** 取 callee 链（MemberExpression.object 逐层下钻）的根标识符名；非链形态返回 null。 */
-function rootIdentifierOfCallee(callee) {
-    let cur = callee;
-    while (cur && typeof cur === 'object') {
-        if (cur.type === 'Identifier')
-            return cur.name;
-        if (cur.type === 'MemberExpression') {
-            cur = cur.object;
-            continue;
-        }
-        return null;
-    }
-    return null;
-}
-/**
- * 预检：节点是否「需整体降级为 ExprIR」——数组内出现折叠失败（引用变量）且自身
- * ∈ 白名单的表达式元素。折叠成功 / 纯字面量 / 参数 / 变量引用 / 嵌套调用均返回
- * false（维持现状路径）；未知标识符等非法形态也返回 false（由现状路径报错）。
- * 对象不整体降级（属性值各自递归降级，见 isExprWhitelist 注释）。
- */
-function needsExprFallback(node, paramNames, paramValues) {
-    if (!node || typeof node !== 'object')
-        return false;
-    switch (node.type) {
-        case 'Literal':
-        case 'Identifier':
-        case 'ObjectExpression':
-            return false;
-        case 'UnaryExpression':
-        case 'BinaryExpression':
-        case 'LogicalExpression':
-        case 'TemplateLiteral':
-        case 'ConditionalExpression': {
-            if (tryFoldConstExpr(node, paramNames, paramValues).ok)
-                return false;
-            return isExprWhitelist(node);
-        }
-        case 'ArrayExpression':
-            return node.elements.some((el) => el !== null && el !== undefined && needsExprFallback(el, paramNames, paramValues));
-        default:
-            return false;
-    }
-}
-/**
- * 递归收集 ExprIR 引用的参数名 / 变量名：Identifier → 参数进 params（ctx 键）、
- * 已声明变量进 refs（VarRef 语义）、未知标识符 → E_REFERENCE（loose 模式透传为 partName）。
- */
-function collectExprIdentifiers(node, paramNames, varToId, line, params, refs, looseVars) {
-    if (!node || typeof node !== 'object')
-        return;
-    switch (node.type) {
-        case 'Identifier': {
-            const name = node.name;
-            if (paramNames.has(name)) {
-                params.add(name);
-            }
-            else if (varToId.has(name)) {
-                refs.add(String(varToId.get(name)));
-            }
-            else if (looseVars) {
-                // Loose mode: external variable passes through as its physical PartName
-                // (the append prefix is validated by the caller against the persistent ctx).
-                refs.add(String(asPartName(name)));
-                varToId.set(name, asPartName(name));
-            }
-            else {
-                throw new ParseError(`unknown identifier "${name}" in expression`, getLine(node), 'E_REFERENCE');
-            }
-            return;
-        }
-        case 'UnaryExpression':
-            collectExprIdentifiers(node.argument, paramNames, varToId, line, params, refs, looseVars);
-            return;
-        case 'BinaryExpression':
-        case 'LogicalExpression':
-            collectExprIdentifiers(node.left, paramNames, varToId, line, params, refs, looseVars);
-            collectExprIdentifiers(node.right, paramNames, varToId, line, params, refs, looseVars);
-            return;
-        case 'ConditionalExpression':
-            collectExprIdentifiers(node.test, paramNames, varToId, line, params, refs, looseVars);
-            collectExprIdentifiers(node.consequent, paramNames, varToId, line, params, refs, looseVars);
-            collectExprIdentifiers(node.alternate, paramNames, varToId, line, params, refs, looseVars);
-            return;
-        case 'ArrayExpression':
-            for (const el of node.elements) {
-                collectExprIdentifiers(el, paramNames, varToId, line, params, refs, looseVars);
-            }
-            return;
-        case 'ObjectExpression':
-            for (const prop of node.properties) {
-                if (prop?.type !== 'Property')
-                    continue;
-                // shorthand { w } 的 value 即 Identifier(w)，直接收集即可
-                collectExprIdentifiers(prop.value, paramNames, varToId, line, params, refs, looseVars);
-            }
-            return;
-        case 'MemberExpression': {
-            // 成员链：沿 .object 走到根标识符收为 ref（p0.solid → refs=['p0']；
-            // p0.holes[0].center → refs=['p0']）；computed 属性表达式递归收集。
-            collectExprIdentifiers(node.object, paramNames, varToId, line, params, refs, looseVars);
-            if (node.computed) {
-                collectExprIdentifiers(node.property, paramNames, varToId, line, params, refs, looseVars);
-            }
-            return;
-        }
-        case 'CallExpression': {
-            // 方法调用 a.b(c)：callee 链与实参递归收集（命名空间根调用已被 buildExprIR 守卫拦截）
-            collectExprIdentifiers(node.callee, paramNames, varToId, line, params, refs, looseVars);
-            for (const a of node.arguments) {
-                collectExprIdentifiers(a.type === 'SpreadElement' ? a.argument : a, paramNames, varToId, line, params, refs, looseVars);
-            }
-            return;
-        }
-        default:
-            return;
-    }
-}
-/** 构建 ExprIR：原文切片（acorn 坐标相对 sourceText）+ 引用名集合；置 hasComputedArgs。
- *  守卫：含命名空间根调用的表达式显式 E_VALUE（命名空间绑定在语句 fn 体箭头包装
- *  作用域内不可见，整体单实参的命名空间调用应走 CallRefIR）。 */
-function buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames) {
-    if (containsNsRootedCall(node, nsNames)) {
-        throw new ParseError('namespace calls are only supported as a whole argument value (CallRefIR), not inside a larger expression', line, 'E_VALUE');
-    }
-    const params = new Set();
-    const refs = new Set();
-    collectExprIdentifiers(node, paramNames, varToId, line, params, refs, looseVars);
-    if (flags)
-        flags.computed = true;
-    return {
-        $expr: {
-            text: sourceText.slice(node.start, node.end),
-            refs: [...refs],
-            params: [...params],
-        },
-    };
-}
-/** 解析字面量 / 数组 / 对象 / ParamRefIR / GeomRef（F1：支持可静态折叠的表达式） */
-function parseValueExpr(node, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars = false, sourceText = '') {
-    if (!node)
-        throw new ParseError('missing value expression', line, 'E_VALUE');
-    switch (node.type) {
-        case 'Literal':
-            return node.value;
-        case 'Identifier': {
-            // 裸标识符：参数变量 → ParamRefIR；已声明变量 → VarRefIR（A7 消灭后通用）
-            const name = node.name;
-            if (paramNames.has(name)) {
-                const ref = { $param: name };
-                return ref;
-            }
-            const varId = varToId.get(name);
-            if (varId) {
-                return { $ref: varId };
-            }
-            // Loose mode (append passes only the newest statements): an external
-            // variable passes through as its physical PartName; the caller validates
-            // it against the persistent ctx (AppendPrefixError when missing).
-            if (looseVars) {
-                const external = asPartName(name);
-                varToId.set(name, external);
-                return { $ref: external };
-            }
-            throw new ParseError(`unknown identifier "${name}" in args value (not a declared param or variable)`, line, 'E_REFERENCE');
-        }
-        case 'ArrayExpression': {
-            // ExprIR 降级：数组含折叠失败（引用变量）的白名单表达式元素 → 整体作为运行时表达式
-            if (needsExprFallback(node, paramNames, paramValues)) {
-                return buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames);
-            }
-            const out = [];
-            for (const el of node.elements) {
-                if (el === null || el === undefined) {
-                    throw new ParseError('array holes are not supported in args', line, 'E_VALUE');
-                }
-                if (el.type === 'SpreadElement') {
-                    // [...parts]：parts 须为可折叠的数组参数/字面量
-                    const r = tryFoldConstExpr(el.argument, paramNames, paramValues);
-                    if (!r.ok || !Array.isArray(r.value)) {
-                        throw new ParseError('cannot statically evaluate spread in args (must reference an array param or literal)', line, 'E_VALUE');
-                    }
-                    if (flags)
-                        flags.computed = true;
-                    out.push(...r.value);
-                }
-                else {
-                    out.push(parseValueExpr(el, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText));
-                }
-            }
-            return out;
-        }
-        case 'ObjectExpression': {
-            // ExprIR 降级：对象含折叠失败（引用变量）的白名单表达式属性值 → 整体作为运行时表达式
-            if (needsExprFallback(node, paramNames, paramValues)) {
-                return buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames);
-            }
-            const obj = {};
-            for (const prop of node.properties) {
-                if (prop.type === 'SpreadElement') {
-                    // {...opts}：opts 须为可折叠的对象参数/字面量
-                    const r = tryFoldConstExpr(prop.argument, paramNames, paramValues);
-                    if (!r.ok || typeof r.value !== 'object' || r.value === null || Array.isArray(r.value)) {
-                        throw new ParseError('cannot statically evaluate object spread in args', line, 'E_VALUE');
-                    }
-                    if (flags)
-                        flags.computed = true;
-                    Object.assign(obj, r.value);
-                    continue;
-                }
-                // shorthand property: { size } → { size: size }
-                const key = prop.key.type === 'Identifier' ? prop.key.name
-                    : prop.key.type === 'Literal' ? String(prop.key.value)
-                        : null;
-                if (key === null) {
-                    throw new ParseError(`invalid object key`, line, 'E_VALUE');
-                }
-                // shorthand: { size } → value is the same identifier
-                if (prop.shorthand) {
-                    if (paramNames.has(key)) {
-                        obj[key] = { $param: key };
-                    }
-                    else {
-                        throw new ParseError(`unknown shorthand identifier "${key}" (not a declared param)`, line, 'E_REFERENCE');
-                    }
-                }
-                else {
-                    obj[key] = parseValueExpr(prop.value, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText);
-                }
-            }
-            return obj;
-        }
-        case 'CallExpression': {
-            // 嵌套调用 → CallRefIR（A7 消灭后任意 <ns>.<ident>(...) 都合法；F2 放开命名空间）
-            const callee = node.callee;
-            if (callee?.type === 'MemberExpression' &&
-                callee.object?.type === 'Identifier' &&
-                nsNames.has(callee.object.name) &&
-                callee.property?.type === 'Identifier') {
-                const nsName = callee.object.name;
-                const innerCallee = callee.property.name;
-                const innerArgs = node.arguments.map((a) => parseValueExpr(a, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText));
-                return {
-                    $call: {
-                        callee: innerCallee,
-                        args: innerArgs,
-                        ...(nsName !== defaultNsName ? { namespace: nsName } : {}),
-                    },
-                };
-            }
-            // D2 扩展：非命名空间调用（方法调用 a.b(c) / 裸调用）∈ 白名单 → ExprIR；
-            // 白名单外（new/箭头/可选链等红线或语义空白）→ E_VALUE（显式禁止而非默认拒绝）
-            if (isExprWhitelist(node)) {
-                return buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames);
-            }
-            throw new ParseError('nested calls in args must be <ns>.<ident>(...) or a whitelisted expression', line, 'E_VALUE');
-        }
-        // D2 扩展：成员访问（p0.solid / p0.holes[0].center）∈ 白名单 → ExprIR（原文切片运行时求值）
-        case 'MemberExpression': {
-            if (isExprWhitelist(node)) {
-                return buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames);
-            }
-            throw new ParseError(`unsupported member expression in args: optional chaining is not allowed`, line, 'E_VALUE');
-        }
-        // F1 扩展：可静态折叠的表达式（无控制流 → 参数值已知，编译期求值）
-        case 'UnaryExpression':
-        case 'BinaryExpression':
-        case 'LogicalExpression':
-        case 'TemplateLiteral':
-        case 'ConditionalExpression': {
-            const r = tryFoldConstExpr(node, paramNames, paramValues);
-            if (!r.ok) {
-                // ExprIR 降级：折叠失败（引用了语句变量等）且节点 ∈ 白名单文法
-                // → 运行时求值（§3.3 / §4.3）；白名单外 → E_VALUE
-                if (isExprWhitelist(node)) {
-                    return buildExprIR(node, paramNames, varToId, line, flags, looseVars, sourceText, nsNames);
-                }
-                throw new ParseError(`cannot statically evaluate ${node.type} in args (must reference declared params or literals)`, line, 'E_VALUE');
-            }
-            // F1-E1：仅当折叠表达式引用了已声明的参数才标 computed。
-            // 纯字面量（含负数字面量，acorn 用 UnaryExpression 表示 -10）不标 computed，
-            // 避免宿主把普通字面量参数误判为「计算参数」而降级为只读（时间线无法回填编辑）。
-            if (flags && r.usedParam)
-                flags.computed = true;
-            return r.value;
-        }
-        default:
-            throw new ParseError(`unsupported value expression: ${node.type}`, line, 'E_VALUE');
-    }
-}
-// ── 位置实参解析（true-JS-subset 方案 §4.2.1：五种顶层调用形态统一入口） ──
-/**
- * 解析一条顶层调用语句的全部位置实参（true-JS-subset 方案 §4.2.1）。
- *
- * 位置实参槽接受任意合法 JS 表达式：变量引用（Identifier → VarRefIR，参数也在
- * varToId 中）、字面量、数组、对象（尾随对象同时投影为 args 选项槽）、
- * `<ns>.<fn>(...)` 嵌套调用（CallRefIR）、可折叠运算、白名单表达式（ExprIR，
- * 含 MemberExpression / 方法调用）。SpreadElement 仅接受可静态折叠的数组参数/
- * 字面量（展开为多个位置实参）。红线形态（new / 箭头函数 / await 等）由
- * parseValueExpr 的 default 分支显式 E_VALUE。
- *
- * @param argNodes - the raw AST argument nodes of the call.
- * @param label - error-message context (e.g. 'inputs', 'destructuring inputs', 'myFn() call').
- * @returns the positional ArgIR list in call order.
- */
-function parsePositionalArgs(argNodes, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText, label) {
-    const out = [];
-    for (const argNode of argNodes) {
-        if (argNode.type === 'Identifier') {
-            // 位置变量引用：varToId 统一解析（参数声明也在表中，与原 inputs 语义一致）
-            const inputId = varToId.get(argNode.name);
-            if (inputId) {
-                out.push({ $ref: inputId });
-                continue;
-            }
-            // Loose mode: external variable passes through as its physical PartName
-            // (the append prefix is validated by the caller against the persistent ctx).
-            if (looseVars) {
-                const external = asPartName(argNode.name);
-                varToId.set(argNode.name, external);
-                out.push({ $ref: external });
-                continue;
-            }
-            throw new ParseError(`unknown variable "${argNode.name}" in ${label}`, getLine(argNode), 'E_REFERENCE');
-        }
-        if (argNode.type === 'SpreadElement') {
-            // [...parts]：parts 须为可折叠的数组参数/字面量（展开为多个位置实参）
-            const r = tryFoldConstExpr(argNode.argument, paramNames, paramValues);
-            if (!r.ok || !Array.isArray(r.value)) {
-                throw new ParseError('cannot statically evaluate spread in arguments (must reference an array param or literal)', line, 'E_VALUE');
-            }
-            flags.computed = true;
-            out.push(...r.value);
-            continue;
-        }
-        out.push(parseValueExpr(argNode, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText));
-    }
-    return out;
-}
-/**
- * 解析一条 `const varName = [await] <ns>.<op>(...)` 语句。
- */
-/**
- * ABI 绑定校验（§3.6 / D11 / true-JS-subset §4.2.4）：本机函数调用 `myFn(a1..aM, { key1: v1, ... })`，
- * 设形参表 [p1..pk]：
- * 1. 位置实参 a1..aM 按序绑定 p1..pM（M ≤ k，超出 → E_ARG）；位置实参可为任意
- *    合法 JS 表达式形态（只数个数，不再要求 Identifier——true-JS-subset 放开）；
- * 2. 尾部对象键绑定剩余形参 p_{M+1}..p_k（按名）；未知键 / 与位置占用冲突 → E_ARG；
- * 3. 未被绑定的形参 → undefined（JS 语义，不报错）；
- * 4. keep/keepHidden 键先剥离，不参与形参校验（§3.6 第 4 条）。
- * @param callee - 函数名（错误消息用）。
- * @param params - 函数形参表（来自 parseScript 预扫描的 localFnParams）。
- * @param positionalCount - 位置实参个数（M）。
- * @param args - 尾部对象键值（keep/keepHidden 可能仍在其中，校验时跳过）。
- * @param line - 报错行号。
- */
-function validateLocalAbi(callee, params, positionalCount, args, line) {
-    const M = positionalCount;
-    if (M > params.length) {
-        throw new ParseError(`function "${callee}" takes at most ${params.length} positional argument(s), got ${M}`, line, 'E_ARG');
-    }
-    for (const key of Object.keys(args)) {
-        if (key === 'keep' || key === 'keepHidden')
-            continue;
-        const idx = params.indexOf(key);
-        if (idx === -1) {
-            throw new ParseError(`function "${callee}" has no parameter named "${key}"`, line, 'E_ARG');
-        }
-        if (idx < M) {
-            throw new ParseError(`function "${callee}" parameter "${key}" is already bound by a positional argument`, line, 'E_ARG');
-        }
-    }
-}
-function parseCadStatement(declNode, paramNames, paramValues, varToId, nsNames, defaultNsName, looseVars = false, sourceText = '', localFnParams, looseLocalCalls = false) {
-    const line = getLine(declNode);
-    // 提取变量名
-    if (declNode.id?.type !== 'Identifier') {
-        throw new ParseError('expected identifier on left side of const declaration', line, 'E_STATEMENT');
-    }
-    const varName = declNode.id.name;
-    // 提取 init（可能包在 AwaitExpression 里）
-    let init = declNode.init;
-    if (init?.type === 'AwaitExpression') {
-        init = init.argument;
-    }
-    // init 必须是 CallExpression
-    if (init?.type !== 'CallExpression') {
-        throw new ParseError(`expected <ns>.<op>(...) or local function call, got ${init?.type ?? 'null'}`, line, 'E_STATEMENT');
-    }
-    const callee = init.callee;
-    // 命名空间调用：callee 是 MemberExpression <ns>.<op>（cad 或顶层 import 绑定名，F2 消灭硬编码）
-    const isNsCall = callee?.type === 'MemberExpression' &&
-        callee.object?.type === 'Identifier' &&
-        nsNames.has(callee.object.name) &&
-        callee.property?.type === 'Identifier';
-    // 本机函数调用：callee 是裸标识符且 ∈ 脚本函数集（§3.4 / §4.2）
-    const isLocalCall = callee?.type === 'Identifier' && (localFnParams?.has(callee.name) ?? false);
-    // 宽松本机调用（单行提取 codeToArgs）：裸 callee 不在函数集时也放行，
-    // 视为 local 调用候选（ABI 形态未知 → 跳过绑定校验），由调用方在完整上下文校验。
-    const looseLocalCall = !isLocalCall && looseLocalCalls && callee?.type === 'Identifier';
-    if (!isNsCall && !isLocalCall && !looseLocalCall) {
-        // 裸 callee 且不在函数集 → 「函数不存在」（E_REFERENCE，§3.4 / D15）；其余形态 → E_STATEMENT
-        if (callee?.type === 'Identifier') {
-            throw new ParseError(`function "${callee.name}" does not exist in this script`, line, 'E_REFERENCE');
-        }
-        throw new ParseError('expected <ns>.<op>(...) or local function call', line, 'E_STATEMENT');
-    }
-    const nsName = isNsCall ? callee.object.name : undefined;
-    const opName = isNsCall ? callee.property.name : callee.name;
-    const local = isLocalCall || looseLocalCall;
-    // 位置实参统一解析（true-JS-subset §4.2.1）：变量/字面量/对象/嵌套调用/表达式任意混排；
-    // 尾随纯对象同时投影为 args 选项槽。不再有"args = parsed 覆盖赋值"静默坑（D5：多对象按位置如实传递）。
-    const flags = { computed: false };
-    const positional = parsePositionalArgs(init.arguments, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText, 'inputs');
-    const args = splitPositionalOptions(positional).named;
-    // 本机调用：ABI 绑定校验（§3.6，parse 期拦截 E_ARG）
-    // 位置实参个数校验（形态校验已删——任意合法 JS 表达式均可占位，§4.2.4）。
-    // 宽松本机调用（codeToArgs 单行提取）形参未知 → 跳过绑定校验，由调用方在完整上下文校验。
-    if (local && localFnParams && !looseLocalCall) {
-        const { values, named } = splitPositionalOptions(positional);
-        validateLocalAbi(opName, localFnParams.get(opName) ?? [], values.length, named, line);
-    }
-    // Phase 3：id 不再赋变量名，由最终遍历赋 sN；变量名记录到 declaredOutputs
-    const stmt = {
-        id: asStmtId('__pending__'),
-        callee: opName,
-        args,
-        positional,
-        outputs: [],
-        hasAssignment: true,
-        ...(local ? { local: true } : nsName !== defaultNsName ? { namespace: nsName } : {}),
-        ...(flags.computed ? { hasComputedArgs: true } : {}),
-    };
-    return { stmt, varName, declaredOutputs: [varName] };
-}
-/**
- * 解析 `const { k1: v1, k2: v2 } = [await] <ns>.<any>(...)` 或本机函数调用（§3.4）。
- *
- * 任意键数（1..N）、任意 callee（不再限 split/front/back）；本机函数调用走 local 分支。
- */
-function parseDestructuring(declNode, paramNames, paramValues, varToId, nsNames, defaultNsName, looseVars = false, sourceText = '', localFnParams, looseLocalCalls = false) {
-    const line = getLine(declNode);
-    // id 必须是 ObjectPattern
-    if (declNode.id?.type !== 'ObjectPattern') {
-        throw new ParseError('expected object pattern for destructuring', line, 'E_STATEMENT');
-    }
-    const props = declNode.id.properties;
-    if (props.length === 0) {
-        throw new ParseError('destructuring must have at least one property', line, 'E_STATEMENT');
-    }
-    const keys = [];
-    const valueNames = [];
-    for (const prop of props) {
-        if (prop.type !== 'Property' || prop.key?.type !== 'Identifier') {
-            throw new ParseError('destructuring properties must be identifiers', line, 'E_STATEMENT');
-        }
-        if (prop.value?.type !== 'Identifier') {
-            throw new ParseError(`destructuring value for "${prop.key.name}" must be an identifier`, line, 'E_STATEMENT');
-        }
-        keys.push(prop.key.name);
-        valueNames.push(prop.value.name);
-    }
-    // 提取 init（可包 AwaitExpression），必须是调用（命名空间或本机函数）
-    let init = declNode.init;
-    if (init?.type === 'AwaitExpression') {
-        init = init.argument;
-    }
-    if (init?.type !== 'CallExpression') {
-        throw new ParseError(`expected <ns>.<op>(...) or local function call in destructuring, got ${init?.type ?? 'null'}`, line, 'E_STATEMENT');
-    }
-    const callee = init.callee;
-    const isNsCall = callee?.type === 'MemberExpression' &&
-        callee.object?.type === 'Identifier' &&
-        nsNames.has(callee.object.name) &&
-        callee.property?.type === 'Identifier';
-    const isLocalCall = callee?.type === 'Identifier' && (localFnParams?.has(callee.name) ?? false);
-    // 宽松本机调用（单行提取 codeToArgs）：裸 callee 不在函数集时也放行，
-    // 视为 local 调用候选（ABI 形态未知 → 跳过绑定校验），由调用方在完整上下文校验。
-    const looseLocalCall = !isLocalCall && looseLocalCalls && callee?.type === 'Identifier';
-    if (!isNsCall && !isLocalCall && !looseLocalCall) {
-        if (callee?.type === 'Identifier') {
-            throw new ParseError(`function "${callee.name}" does not exist in this script`, line, 'E_REFERENCE');
-        }
-        throw new ParseError('destructuring is only allowed for <ns>.<op>(...) or local function calls', line, 'E_STATEMENT');
-    }
-    const nsName = isNsCall ? callee.object.name : undefined;
-    const opName = isNsCall ? callee.property.name : callee.name;
-    const local = isLocalCall || looseLocalCall;
-    // 位置实参统一解析（true-JS-subset §4.2.1）；尾随纯对象同时投影为 args 选项槽。
-    // 旧 Object.assign 合并已删（D5：多对象按位置如实传递，不合并不覆盖）。
-    const flags = { computed: false };
-    const positional = parsePositionalArgs(init.arguments, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, sourceText, 'destructuring inputs');
-    const args = splitPositionalOptions(positional).named;
-    // 本机调用：ABI 绑定校验（§3.6，parse 期拦截 E_ARG）
-    // 宽松本机调用（codeToArgs 单行提取）形参未知 → 跳过绑定校验，由调用方在完整上下文校验。
-    if (local && localFnParams && !looseLocalCall) {
-        const { values, named } = splitPositionalOptions(positional);
-        validateLocalAbi(opName, localFnParams.get(opName) ?? [], values.length, named, line);
-    }
-    // Phase 3：id 不再赋变量名；outputs 在最终遍历经 varToId 解析后写入
-    const stmt = {
-        id: asStmtId('__pending__'),
-        callee: opName,
-        args,
-        positional,
-        outputs: [],
-        outputKeys: keys,
-        hasAssignment: true,
-        ...(local ? { local: true } : nsName !== defaultNsName ? { namespace: nsName } : {}),
-        ...(flags.computed ? { hasComputedArgs: true } : {}),
-    };
-    return { stmt, valueNames, declaredOutputs: valueNames };
-}
-// ── meta 解析 ──
-/**
- * 解析 return 语句，提取 terminal shape(s) 和 meta。
- *
- * 支持三种形式：
- * - `return part0`（裸标识符）→ 单终端，无 meta
- * - `return { shape: part0, name, color, ... }`（单终端 + meta）
- * - `return [ { shape: part1, name, ... }, { shape: part2, name, ... } ]`（多终端）
- */
-function parseReturnStatement(node, varToId) {
-    const line = getLine(node);
-    const arg = node.argument;
-    if (!arg) {
-        return { terminalShapeId: null, meta: undefined, terminalShapes: undefined };
-    }
-    // return part0（裸标识符）
-    if (arg.type === 'Identifier') {
-        const ref = varToId.get(arg.name);
-        if (!ref) {
-            throw new ParseError(`unknown variable "${arg.name}" in return`, line);
-        }
-        return { terminalShapeId: ref, meta: undefined, terminalShapes: undefined };
-    }
-    // return { shape: part0, name, color, ... }
-    if (arg.type === 'ObjectExpression') {
-        const result = parseReturnObject(arg, varToId, line);
-        return { terminalShapeId: result.id, meta: result.meta, terminalShapes: undefined };
-    }
-    // return [ { shape: ... }, ... ]（多终端）
-    if (arg.type === 'ArrayExpression') {
-        const terminalShapes = [];
-        for (const elem of arg.elements) {
-            if (elem?.type !== 'ObjectExpression') {
-                throw new ParseError('return array elements must be objects { shape, ... }', line);
-            }
-            const result = parseReturnObject(elem, varToId, line);
-            if (result.id) {
-                terminalShapes.push({ id: result.id, meta: result.meta });
-            }
-        }
-        if (terminalShapes.length === 0) {
-            throw new ParseError('return array must have at least one element', line);
-        }
-        // 单元素数组等价为单终端
-        if (terminalShapes.length === 1) {
-            return { terminalShapeId: terminalShapes[0].id, meta: terminalShapes[0].meta, terminalShapes: undefined };
-        }
-        return { terminalShapeId: null, meta: undefined, terminalShapes };
-    }
-    throw new ParseError(`unsupported return expression: ${arg.type}`, line);
-}
-/** 解析单个 return 元素 { shape: varName, name?, color?, metalness?, roughness? } */
-function parseReturnObject(objNode, varToId, line) {
-    let id = null;
-    const meta = {};
-    for (const prop of objNode.properties) {
-        const key = prop.key?.type === 'Identifier' ? prop.key.name
-            : prop.key?.type === 'Literal' ? String(prop.key.value)
-                : null;
-        if (!key)
-            continue;
-        if (key === 'shape') {
-            if (prop.value?.type === 'Identifier') {
-                const ref = varToId.get(prop.value.name);
-                if (!ref) {
-                    throw new ParseError(`unknown variable "${prop.value.name}" in return shape`, line);
-                }
-                id = ref;
-            }
-        }
-        else if (key === 'name') {
-            if (prop.value?.type === 'Literal') {
-                meta.name = prop.value.value;
-            }
-        }
-        else if (key === 'color') {
-            if (prop.value?.type === 'Literal') {
-                if (!meta.appearance)
-                    meta.appearance = {};
-                meta.appearance.color = prop.value.value;
-            }
-        }
-        else if (key === 'metalness') {
-            if (prop.value?.type === 'Literal') {
-                if (!meta.appearance)
-                    meta.appearance = {};
-                meta.appearance.metalness = prop.value.value;
-            }
-        }
-        else if (key === 'roughness') {
-            if (prop.value?.type === 'Literal') {
-                if (!meta.appearance)
-                    meta.appearance = {};
-                meta.appearance.roughness = prop.value.value;
-            }
-        }
-    }
-    return { id, meta: Object.keys(meta).length > 0 ? meta : undefined };
-}
-// ── 引用收集（Phase 1: VM 执行 deps 计算） ──
-/** 递归收集 ArgIR 中的变量引用：$param → 参数名；$ref → 变量名；$call → 递归收集内部 args；$expr → refs/params 并入（§4.3）。 */
-function collectRefsFromArg(value, out) {
-    if (value === null || value === undefined)
-        return;
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
-        return;
-    if (isParamRef(value)) {
-        out.add(value.$param);
-        return;
-    }
-    if (isVarRef(value)) {
-        out.add(value.$ref);
-        return;
-    }
-    if (isCallRef(value)) {
-        for (const a of value.$call.args)
-            collectRefsFromArg(a, out);
-        return;
-    }
-    if (isExprRef(value)) {
-        for (const p of value.$expr.params)
-            out.add(p);
-        for (const r of value.$expr.refs)
-            out.add(r);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const v of value)
-            collectRefsFromArg(v, out);
-        return;
-    }
-    if (typeof value === 'object') {
-        for (const v of Object.values(value))
-            collectRefsFromArg(v, out);
-    }
-}
-/**
- * 收集单条语句引用的全部变量名（positional + args 中 $param / $ref / 嵌套调用 /
- * ExprIR refs/params + receiver）。positional 与 args 都扫：args 是尾随对象投影
- * （真源 positional 已含它，重复扫描幂等）；手工构造 IR 可能只填 args。
- * 存入 stmt.refs，编译期据此翻译为 deps（定义这些变量的语句 id）。
- */
-function collectStatementRefs(stmt) {
-    const refs = new Set();
-    for (const arg of stmt.positional)
-        collectRefsFromArg(arg, refs);
-    for (const arg of Object.values(stmt.args))
-        collectRefsFromArg(arg, refs);
-    // receiver：成员方法调用（add_constraint/do_assemble 等）依赖其 receiver 变量，
-    // 不加入则成员调用对 compound 的依赖边缺失（连带 bug，见命名分层修复文档 §2.4）。
-    if (stmt.receiver)
-        refs.add(stmt.receiver);
-    return [...refs];
-}
-// ── 语句黑名单（F1：白名单 → 黑名单） ──
-/** 控制流语句（faijs 唯一禁令，V1.5 专用错误码）。 */
-const CONTROL_FLOW_TYPES = new Set([
-    'IfStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement',
-    'WhileStatement', 'DoWhileStatement', 'SwitchStatement', 'TryStatement',
-    'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'LabeledStatement',
-    'WithStatement',
-]);
-/** 文本仅含注释与空白（import 头部连续段约束用）。 */
-function onlyWhitespaceAndComments(text) {
-    return text
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/\/\/[^\n]*/g, '')
-        .trim() === '';
-}
-/** 文本行数（空文本 = 0；含 n 个换行的文本 = n+1 行）。 */
-function countLines(text) {
-    if (text === '')
-        return 0;
-    return (text.match(/\n/g) ?? []).length + 1;
-}
-/** 由 specifier 推导包名：@scope/pkg/sub → @scope/pkg；gear-lib-demo → gear-lib-demo。 */
-function derivePackageName(specifier) {
-    if (specifier.startsWith('@')) {
-        const parts = specifier.split('/');
-        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
-    }
-    return specifier.split('/')[0];
-}
-/** ImportDeclaration → ImportIR（F2）。 */
-function importDeclToIR(decl, line) {
-    const specifier = decl.source?.value;
-    if (typeof specifier !== 'string' || specifier === '') {
-        throw new ParseError('import must have a string specifier', line, 'E_IMPORT');
-    }
-    const packageName = derivePackageName(specifier);
-    const specifiers = decl.specifiers ?? [];
-    if (specifiers.length === 0) {
-        throw new ParseError('side-effect imports are not supported (use import * as ns from "pkg")', line, 'E_IMPORT');
-    }
-    const first = specifiers[0];
-    if (first.type === 'ImportNamespaceSpecifier') {
-        const localName = first.local?.name;
-        if (typeof localName !== 'string')
-            throw new ParseError('invalid namespace import binding', line, 'E_IMPORT');
-        return { specifier, kind: 'namespace', localName, packageName };
-    }
-    if (first.type === 'ImportDefaultSpecifier') {
-        const localName = first.local?.name;
-        if (typeof localName !== 'string')
-            throw new ParseError('invalid default import binding', line, 'E_IMPORT');
-        return { specifier, kind: 'default', localName, packageName };
-    }
-    // ImportSpecifier（named）
-    const bindings = specifiers.map((s) => s.local?.name);
-    if (bindings.some((b) => typeof b !== 'string')) {
-        throw new ParseError('invalid named import bindings', line, 'E_IMPORT');
-    }
-    return { specifier, kind: 'named', localName: bindings[0], bindings, packageName };
-}
-/**
- * 默认分支：黑名单式拒绝（normal-js-subset P1）。
- * 除控制流（专用 E_CONTROL_FLOW 码）与安全红线（eval/new/export）外，
- * 未识别的语句形态一律 E_STATEMENT。
- */
-function throwUnsupportedStatement(node, line) {
-    if (CONTROL_FLOW_TYPES.has(node.type)) {
-        throw new ParseError(`control flow statement "${node.type}" is not allowed in faijs`, line, 'E_CONTROL_FLOW');
-    }
-    if (node.type === 'ImportDeclaration') {
-        throw new ParseError('import statements must be at the top level, before any statements', line, 'E_IMPORT');
-    }
-    if (node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') {
-        throw new ParseError('export statements are not allowed (faijs auto-exports the default module)', line, 'E_STATEMENT');
-    }
-    if (node.type === 'ClassDeclaration') {
-        throw new ParseError('class declarations are not allowed in faijs', line, 'E_STATEMENT');
-    }
-    if (node.type === 'NewExpression') {
-        throw new ParseError('"new" expressions are not allowed in faijs (new Function is a safety red line)', line, 'E_STATEMENT');
-    }
-    throw new ParseError(`unsupported statement: ${node.type}`, line, 'E_STATEMENT');
-}
-// ── 顶层函数定义（A1 / 控制流放松方案 Phase 2） ──
-// bodyHash 哈希的唯一家在 fnv-hash.ts（无 IR 方案下 metadata-extractor 复用）。
-/**
- * 解析顶层 `function name(params) { ... }` 为 FunctionDefIR（A1 / Phase 2）。
- *
- * 函数定义**不是几何语句**：不进 statements、不参与 DAG 终端判定；
- * 函数体原文按 acorn 坐标从 parseCode 切片保留，codegen 原样打印回文件（往返保真）。
- *
- * 函数体校验（Phase 2 放行控制流，§3.1 / §3.2）：
- * - 控制流（if/for/while/switch/try/throw/break/continue/labeled）放行；
- * - eval / new / export / class / import / with / 动态 import() 仍拒（P5 安全红线）；
- * - 体内禁止调用本机函数（裸 callee 调用 → E_STATEMENT，D10）；
- * - var 允许（D12，不新增收紧）。
- *
- * @param codeOffset parseCode 相对原始 code 的字符偏移（扁平封装前缀；容器格式为 0）。
- *                   函数体坐标经此换算为相对原始文本，供宿主 bodyRange 使用。
- */
-function parseFunctionDeclaration(node, line, functions, parseCode, codeOffset = 0) {
-    const name = node.id?.name;
-    if (typeof name !== 'string' || name === '') {
-        throw new ParseError('function declaration must have a name', line, 'E_STATEMENT');
-    }
-    // 查重（D14）：localFns 发射与 bodyHash 按名查表要求函数名唯一
-    if (functions.some((f) => f.name === name)) {
-        throw new ParseError(`function "${name}" is already defined (duplicate function names are not allowed)`, line, 'E_STATEMENT');
-    }
-    // 形参：只允许简单 Identifier（解构/默认值/rest 参数不在子集内）
-    const params = [];
-    for (const p of node.params ?? []) {
-        if (p?.type !== 'Identifier') {
-            throw new ParseError('function params must be plain identifiers', line, 'E_STATEMENT');
-        }
-        params.push(p.name);
-    }
-    // 函数体必须是 BlockStatement（acorn 对合法函数声明必然如此，防御性校验）
-    if (node.body?.type !== 'BlockStatement') {
-        throw new ParseError('function body must be a block statement', line, 'E_STATEMENT');
-    }
-    // 函数体校验（Phase 2：放行控制流，保留安全红线，禁体内本机调用）
-    validateFunctionBody(node.body, line);
-    // 函数体原文（花括号内的完整文本，含换行/缩进）——坐标相对 parseCode
-    const body = parseCode.slice(node.body.start + 1, node.body.end - 1);
-    functions.push({
-        name,
-        params,
-        body,
-        bodyHash: fnv1a32(body),
-        bodyRange: { start: node.body.start + 1 - codeOffset, end: node.body.end - 1 - codeOffset },
-    });
-}
-/**
- * 校验函数体（Phase 2，§3.1 / §3.2 / D10 / D12）：
- * - **放行**控制流（if/for/while/switch/try/throw/break/continue/labeled）与 var；
- * - **仍拒**（安全红线 P5）：import 声明 / export / class / eval / new / with / 动态 import()；
- * - **体内禁止本机函数调用**（裸标识符 callee，D10）——递归遍历全部节点（含嵌套函数体）。
- */
-function validateFunctionBody(body, line) {
-    const stack = [body];
-    while (stack.length > 0) {
-        const n = stack.pop();
-        if (n.type === 'ImportDeclaration') {
-            throw new ParseError('import statements are not allowed inside function bodies', line, 'E_IMPORT');
-        }
-        if (n.type === 'ImportExpression') {
-            throw new ParseError('dynamic import() is not allowed in faijs', line, 'E_CONTROL_FLOW');
-        }
-        if (n.type === 'ExportNamedDeclaration' || n.type === 'ExportAllDeclaration') {
-            throw new ParseError('export statements are not allowed in faijs (faijs auto-exports the default module)', line, 'E_STATEMENT');
-        }
-        if (n.type === 'ClassDeclaration') {
-            throw new ParseError('class declarations are not allowed in faijs', line, 'E_STATEMENT');
-        }
-        if (n.type === 'WithStatement') {
-            throw new ParseError('"with" statements are not allowed in faijs (strict mode)', line, 'E_CONTROL_FLOW');
-        }
-        if (n.type === 'NewExpression') {
-            throw new ParseError('"new" expressions are not allowed in faijs (new Function is a safety red line)', line, 'E_STATEMENT');
-        }
-        if (n.type === 'CallExpression') {
-            // eval 安全红线（与顶层一致）
-            if (n.callee?.type === 'Identifier' && n.callee.name === 'eval') {
-                throw new ParseError('eval is not allowed in faijs', line, 'E_STATEMENT');
-            }
-            // D10：体内禁止调用本机函数（裸标识符 callee）——顶层 ABI 与 verbatim 函数体语义冲突
-            if (n.callee?.type === 'Identifier') {
-                throw new ParseError(`calling local function "${n.callee.name}" inside a function body is not allowed (D10): local functions are callable from the top level only`, line, 'E_STATEMENT');
-            }
-        }
-        // 子节点入栈（跳过元数据字段）
-        for (const key of Object.keys(n)) {
-            if (key === 'loc' || key === 'start' || key === 'end' || key === 'range' || key === 'parent')
-                continue;
-            const v = n[key];
-            if (Array.isArray(v)) {
-                for (const item of v) {
-                    if (item && typeof item === 'object' && typeof item.type === 'string')
-                        stack.push(item);
-                }
-            }
-            else if (v && typeof v === 'object' && typeof v.type === 'string') {
-                stack.push(v);
-            }
-        }
-    }
-}
-/**
- * Parse CAD script code text into a ScriptIR.
- *
- * @param code    - the script text to parse.
- * @param options - optional parse options (looseVars enables loose variable
- *                  resolution for partial append text).
- * @returns the parse result (script IR + parse diagnostics).
- */
-export function parseScript(code, options) {
-    const looseVars = options?.looseVars === true;
-    const looseLocalCalls = options?.looseLocalCalls === true;
-    // 默认注入命名空间名（U10/R2）：缺省 'cad'；宿主换默认绑定名时经 options.defaultNs 声明。
-    const defaultNsName = options?.defaultNs ?? 'cad';
-    // ── 0. 顶层 import/export 预扫描（F1 黑名单化 + F2 import 提升） ──
-    // 用 module 模式解析原始文本：
-    // - 顶层 export（非默认导出容器）→ 明确 E_STATEMENT（扁平包装会先被 acorn 以
-    //   SyntaxError 拒绝：'import' and 'export' may appear only at top level）。
-    // - 顶层 import → 收集声明，校验「文件头部连续段」约束（F2），供扁平代码包装提升。
-    let importBlock = null;
-    const prescanImports = [];
-    {
-        const topLevel = [];
-        try {
-            topLevel.push(...acornParse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true, ranges: true }).body);
-        }
-        catch {
-            // 原始文本非合法 module（如含 return）→ 交给主解析报错
-        }
-        for (const n of topLevel) {
-            if (n.type === 'ExportNamedDeclaration' || n.type === 'ExportAllDeclaration') {
-                throw new ParseError(`export statements are not allowed (faijs auto-exports the default module)`, getLine(n) ?? 1, 'E_STATEMENT');
-            }
-            if (n.type === 'ImportDeclaration')
-                prescanImports.push(n);
-        }
-        if (prescanImports.length > 0) {
-            const first = prescanImports[0];
-            const last = prescanImports[prescanImports.length - 1];
-            // 约束 1：import 之前只能有注释/空白（头部连续段）
-            if (!onlyWhitespaceAndComments(code.slice(0, first.start))) {
-                throw new ParseError('import statements must appear as a contiguous block at the top of the file', getLine(first) ?? 1, 'E_IMPORT');
-            }
-            // 约束 2：import 之间只能有注释/空白
-            for (let i = 1; i < prescanImports.length; i++) {
-                const gap = code.slice(prescanImports[i - 1].end, prescanImports[i].start);
-                if (!onlyWhitespaceAndComments(gap)) {
-                    throw new ParseError('import statements must be contiguous (no statements between imports)', getLine(prescanImports[i]) ?? 1, 'E_IMPORT');
-                }
-            }
-            importBlock = { start: first.start, end: last.end };
-        }
-    }
-    // ── 0.5 扁平代码检测与封装 ──
-    // 如果代码不含 `export default`，则自动封装为合法容器。
-    // 含顶层 import 时把 import 段提到 `export default async (cad) => {...}` 之外
-    // （import 不能出现在函数体内，否则 acorn SyntaxError —— D4）。
-    let parseCode = code;
-    // 扁平封装后首行代码在 parseCode 中位于第 2 行；statementLines 须扣掉封装偏移，
-    // 使行号始终相对宿主原始文本（analyzeCode 契约）。
-    // codeOffset：parseCode 坐标 → 原始 code 坐标的字符偏移（函数体 bodyRange 用；容器格式为 0）。
-    let lineOffset = code.includes('export default') ? 0 : 1;
-    let codeOffset = 0;
-    if (lineOffset) {
-        if (importBlock) {
-            const prefix = code.slice(0, importBlock.start);
-            const importText = code.slice(importBlock.start, importBlock.end);
-            const rest = code.slice(importBlock.end);
-            parseCode = `${prefix}${importText}\nexport default async (${defaultNsName}) => {\n${rest}\n}`;
-            lineOffset = countLines(prefix + importText) + 1;
-            // import 段之后的代码（函数定义所在）偏移 = 封装前缀长度（`\nexport default async (<ns>) => {\n` = 29 + len）
-            codeOffset = 29 + defaultNsName.length;
-        }
-        else {
-            parseCode = `export default async (${defaultNsName}) => {\n${code}\n}`;
-            lineOffset = 1;
-            codeOffset = `export default async (${defaultNsName}) => {\n`.length;
-        }
-    }
-    // ── 1. acorn 解析（合法性闸门） ──
-    let ast;
-    try {
-        ast = acornParse(parseCode, {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            locations: true,
-        });
-    }
-    catch (err) {
-        const syntaxErr = err;
-        const line = syntaxErr.loc?.line ?? 1;
-        const msg = syntaxErr.message ?? String(err);
-        throw new ParseError(`SyntaxError: ${msg}`, line, 'E_SYNTAX');
-    }
-    // ── 2. 验证 AST 结构 ──
-    // 顶层必须是 Program，且仅含一个 ExportDefaultDeclaration
-    if (ast.type !== 'Program') {
-        throw new ParseError('expected a module', 1);
-    }
-    const exportDecl = ast.body.find((n) => n.type === 'ExportDefaultDeclaration');
-    if (!exportDecl) {
-        throw new ParseError('missing `export default`', 1);
-    }
-    // export default 必须是 async 箭头函数。
-    // 容器形参名即脚本内对「默认注入命名空间」的引用标识符（U10/R2：缺省约定 'cad'，
-    // 宿主换默认绑定名 g 时经 parseScript options.defaultNs 传入，容器形参须与之一致）。
-    const arrowFn = exportDecl.declaration;
-    if (arrowFn?.type !== 'ArrowFunctionExpression' ||
-        !arrowFn.async ||
-        arrowFn.params.length !== 1 ||
-        arrowFn.params[0]?.type !== 'Identifier' ||
-        arrowFn.params[0].name !== defaultNsName) {
-        throw new ParseError(`expected \`export default async (${defaultNsName}) => { ... }\``, getLine(exportDecl));
-    }
-    // 箭头函数体必须是 BlockStatement
-    const body = arrowFn.body;
-    if (body?.type !== 'BlockStatement') {
-        throw new ParseError('expected arrow function body to be a block statement { ... }', getLine(arrowFn));
-    }
-    // ── 3. walk body ──
-    const params = [];
-    const statements = [];
-    const statementLines = [];
-    /** 顶层函数定义（A1；无函数时保持空数组，ScriptIR 构建时省略） */
-    const functions = [];
-    const paramNames = new Set();
-    /** 参数名 → 字面量值（F1 表达式折叠依据；仅声明在前面的参数可折叠） */
-    const paramValues = new Map();
-    const varToId = new Map();
-    let meta;
-    let terminalShapes;
-    // ── 3.1 顶层 import → ScriptIR.imports + 命名空间绑定表（F2） ──
-    // import 已提升到模块顶层（扁平包装之外）；主解析的 ast.body 顶层直接可取。
-    const scriptImports = [];
-    /** 命名空间绑定名 → 包名（`import * as mech from 'gear-lib-demo'` → mech → gear-lib-demo）。
-     *  只有 namespace 形态的 import 构成语句命名空间（cad 是缺省命名空间）。 */
-    const importBindings = new Map();
-    for (const node of ast.body) {
-        if (node.type !== 'ImportDeclaration')
-            continue;
-        const imp = importDeclToIR(node, getLine(node));
-        scriptImports.push(imp);
-        if (imp.kind === 'namespace')
-            importBindings.set(imp.localName, imp.packageName);
-    }
-    /** 命名空间判定：'cad'（缺省）或顶层 import 绑定名（F2 消灭硬编码）。 */
-    const isNamespaceName = (name) => name === defaultNsName || importBindings.has(name);
-    /** 合法命名空间名集合（parseValueExpr/parseCadStatement/parseDestructuring 共用）。 */
-    const nsNames = new Set([defaultNsName, ...importBindings.keys()]);
-    // ── 3.2 本机函数集预扫描（Phase 2 / §3.4） ──
-    // 函数声明**提升**（可被其后语句调用），且未知函数名 parse 期报 E_REFERENCE——
-    // 故解析语句前预扫描全部顶层 FunctionDeclaration，收集函数名 → 形参表（ABI 校验用）。
-    // 仅顶层函数构成「本机函数集」；函数体内嵌套函数不参与（D10 禁体内调用，体内容器不透明）。
-    const localFnParams = new Map();
-    for (const topNode of body.body) {
-        if (topNode.type !== 'FunctionDeclaration' || topNode.id?.type !== 'Identifier')
-            continue;
-        const params = [];
-        for (const p of topNode.params ?? []) {
-            if (p?.type === 'Identifier')
-                params.push(p.name);
-        }
-        localFnParams.set(topNode.id.name, params);
-    }
-    for (const stmtNode of body.body) {
-        const line = getLine(stmtNode);
-        switch (stmtNode.type) {
-            case 'FunctionDeclaration': {
-                // A1/Phase 2：顶层函数定义。函数定义不是几何语句——不进 statements、
-                // 不参与 DAG 终端判定（不污染终端集），codegen 原样打印回文件（往返保真）。
-                // Phase 2：函数体放行控制流（§3.1），保留安全红线，禁体内本机调用（D10）。
-                parseFunctionDeclaration(stmtNode, line, functions, parseCode, codeOffset);
-                break;
-            }
-            case 'VariableDeclaration': {
-                // 允许 const 和 let（let 仅用于装配变量）；var 保持拒绝（O2 排后）
-                if (stmtNode.kind !== 'const' && stmtNode.kind !== 'let') {
-                    throw new ParseError(`only 'const' or 'let' declarations allowed, got '${stmtNode.kind}'`, line, 'E_STATEMENT');
-                }
-                // F1 黑名单化：多声明器逐个处理（const a = 1, b = 2）
-                for (const decl of stmtNode.declarations) {
-                    const dline = getLine(decl);
-                    // 通用解构：const { k1: v1, k2: v2 } = [await] <ns>.<any>(...)（A2 消灭：任意 callee、任意键）
-                    if (decl.id?.type === 'ObjectPattern') {
-                        if (stmtNode.kind !== 'const') {
-                            throw new ParseError('destructuring requires const', line, 'E_STATEMENT');
-                        }
-                        const { stmt, valueNames } = parseDestructuring(decl, paramNames, paramValues, varToId, nsNames, defaultNsName, looseVars, parseCode, localFnParams, looseLocalCalls);
-                        // 命名服务不再由 parser 调用：parser 只做语法分析，保留词法变量名（设计 §5.1）
-                        stmt.outputs = valueNames.map((n) => asPartName(n));
-                        statements.push(stmt);
-                        statementLines.push(dline);
-                        // varToId 仅用于作用域校验，恒等映射（词法名 → 词法名）
-                        valueNames.forEach((n) => varToId.set(n, asPartName(n)));
-                        continue;
-                    }
-                    // 判断是参数还是语句
-                    let init = decl.init;
-                    const isAwait = init?.type === 'AwaitExpression';
-                    if (isAwait)
-                        init = init.argument;
-                    // 动态 import() → 控制流专用错误码（V1.5；`await import("mod")` 走声明路径）
-                    if (init?.type === 'ImportExpression') {
-                        throw new ParseError('dynamic import() is not allowed in faijs (no control flow)', line, 'E_CONTROL_FLOW');
-                    }
-                    // Phase 3: let 允许用于普通 cad.op() 语句（单入单出复用名时 codegen 产生 let 重赋值）
-                    if (init?.type === 'CallExpression' &&
-                        (
-                        // 命名空间调用：<ns>.<op>(...)（F2：cad 或顶层 import 绑定名）
-                        (init.callee?.type === 'MemberExpression' &&
-                            init.callee.object?.type === 'Identifier' &&
-                            isNamespaceName(init.callee.object.name)) ||
-                            // 裸标识符 callee（本机函数或未知函数名——parseCadStatement 内判 local / E_REFERENCE，§3.4）
-                            init.callee?.type === 'Identifier')) {
-                        // 语句：const partN = [await] <ns>.op(...) 或 const partN = [await] localFn(...)
-                        const { stmt, varName } = parseCadStatement(decl, paramNames, paramValues, varToId, nsNames, defaultNsName, looseVars, parseCode, localFnParams, looseLocalCalls);
-                        // 命名服务不再由 parser 调用：parser 只做语法分析，保留词法变量名（设计 §5.1）
-                        stmt.outputs = [asPartName(varName)];
-                        statements.push(stmt);
-                        statementLines.push(dline);
-                        // varToId 仅用于作用域校验，恒等映射（词法名 → 词法名）
-                        varToId.set(varName, asPartName(varName));
-                    }
-                    else if (init?.type === 'Literal' ||
-                        init?.type === 'ArrayExpression' ||
-                        init?.type === 'ObjectExpression') {
-                        // 参数：const name = literal
-                        if (decl.id?.type !== 'Identifier') {
-                            throw new ParseError('param declaration must have identifier name', line, 'E_STATEMENT');
-                        }
-                        const name = decl.id.name;
-                        // 解析字面量值（不允许 ParamRefIR / GeomRef / 标识符）
-                        const value = parseLiteralOnly(init, dline);
-                        params.push({
-                            name,
-                            type: typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'bool' : 'vec3',
-                            value: value,
-                            default: value,
-                        });
-                        paramNames.add(name);
-                        paramValues.set(name, value);
-                        // F1：参数也可作为 input（cad.fai_drill(p, {...})），加入 varToId 供输入/接收者解析
-                        varToId.set(name, asPartName(name));
-                    }
-                    else {
-                        throw new ParseError(`unsupported const declaration: init type = ${init?.type ?? 'null'}`, line, 'E_STATEMENT');
-                    }
-                }
-                break;
-            }
-            case 'ReturnStatement': {
-                const result = parseReturnStatement(stmtNode, varToId);
-                meta = result.meta;
-                terminalShapes = result.terminalShapes;
-                break;
-            }
-            case 'ExpressionStatement': {
-                const expr = stmtNode.expression;
-                // 动态 import() → 控制流专用错误码（V1.5）
-                if (expr?.type === 'ImportExpression') {
-                    throw new ParseError('dynamic import() is not allowed in faijs (no control flow)', line, 'E_CONTROL_FLOW');
-                }
-                // eval / new Function 安全红线
-                if (expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier' && expr.callee.name === 'eval') {
-                    throw new ParseError('eval is not allowed in faijs', line, 'E_STATEMENT');
-                }
-                if (expr?.type === 'NewExpression') {
-                    throw new ParseError('"new" expressions are not allowed in faijs (new Function is a safety red line)', line, 'E_STATEMENT');
-                }
-                // ── Phase 3: 裸重赋值 part0 = [await] cad.op(...) ──
-                // codegen 对已声明变量的重赋值不使用 let/const，产生裸赋值表达式
-                if (expr?.type === 'AssignmentExpression' &&
-                    expr.operator === '=' &&
-                    expr.left?.type === 'Identifier') {
-                    const varName = expr.left.name;
-                    // 验证变量已声明（loose 模式下外部变量透传，由 append 前缀校验兜底）
-                    if (!varToId.has(varName)) {
-                        if (looseVars) {
-                            varToId.set(varName, asPartName(varName));
-                        }
-                        else {
-                            throw new ParseError(`unknown variable "${varName}" in re-assignment`, line, 'E_REFERENCE');
-                        }
-                    }
-                    let init = expr.right;
-                    if (init?.type === 'AwaitExpression')
-                        init = init.argument;
-                    if (init?.type === 'CallExpression' &&
-                        (
-                        // 命名空间调用：<ns>.<op>(...)
-                        (init.callee?.type === 'MemberExpression' &&
-                            init.callee.object?.type === 'Identifier' &&
-                            isNamespaceName(init.callee.object.name) &&
-                            init.callee.property?.type === 'Identifier') ||
-                            // 裸标识符 callee（本机函数或未知函数名——parseCadStatement 内判 local / E_REFERENCE，§3.4）
-                            init.callee?.type === 'Identifier')) {
-                        // 复用 parseCadStatement 的内部逻辑
-                        const fakeDecl = {
-                            id: { type: 'Identifier', name: varName },
-                            init: expr.right,
-                            loc: stmtNode.loc,
-                        };
-                        const { stmt, varName: parsedVar } = parseCadStatement(fakeDecl, paramNames, paramValues, varToId, nsNames, defaultNsName, looseVars, parseCode, localFnParams, looseLocalCalls);
-                        // 命名服务不再由 parser 调用：裸重赋值保留词法变量名（设计 §5.1）
-                        stmt.outputs = [asPartName(parsedVar)];
-                        statements.push(stmt);
-                        statementLines.push(line);
-                        // varToId 仅用于作用域校验，恒等映射（词法名 → 词法名）
-                        varToId.set(parsedVar, asPartName(parsedVar));
-                        break;
-                    }
-                    throw new ParseError(`re-assignment must be a cad.op() call`, line, 'E_STATEMENT');
-                }
-                // ── 本机函数无赋值调用（§3.4 四形态之四：副作用调用） ──
-                // myFn(part0, { ... }) —— callee 是裸标识符且 ∈ 函数集；未知函数名 → E_REFERENCE
-                // 宽松本机调用（codeToArgs 单行提取）：裸 callee 不在函数集时也放行，
-                // 视为 local 调用候选（ABI 形态未知 → 跳过绑定校验），由调用方在完整上下文校验。
-                if (expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier') {
-                    const fnName = expr.callee.name;
-                    const looseLocal = looseLocalCalls && !localFnParams.has(fnName);
-                    if (localFnParams.has(fnName) || looseLocal) {
-                        const flags = { computed: false };
-                        const positional = parsePositionalArgs(expr.arguments, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, parseCode, `${fnName}() call`);
-                        const args = splitPositionalOptions(positional).named;
-                        // 宽松本机调用（codeToArgs 单行提取）形参未知 → 跳过绑定校验，由调用方在完整上下文校验。
-                        if (!looseLocal) {
-                            const { values, named } = splitPositionalOptions(positional);
-                            validateLocalAbi(fnName, localFnParams.get(fnName) ?? [], values.length, named, line);
-                        }
-                        const localStmt = {
-                            id: asStmtId('__pending__'),
-                            callee: fnName,
-                            args,
-                            positional,
-                            outputs: [],
-                            local: true,
-                            hasAssignment: false,
-                            ...(flags.computed ? { hasComputedArgs: true } : {}),
-                        };
-                        statements.push(localStmt);
-                        statementLines.push(line);
-                        break;
-                    }
-                    // 裸 callee 不在函数集 → 「函数不存在」（E_REFERENCE，§3.4 / D15）
-                    throw new ParseError(`function "${fnName}" does not exist in this script`, line, 'E_REFERENCE');
-                }
-                // ── 成员方法调用（A6 消灭：任意方法名；receiver 须已声明） ──
-                // assem1.add_constraint({ ... }) / assem1.do_assemble() / assem1.myMethod()
-                if (expr?.type === 'CallExpression' &&
-                    expr.callee?.type === 'MemberExpression' &&
-                    expr.callee.object?.type === 'Identifier' &&
-                    expr.callee.property?.type === 'Identifier') {
-                    const objName = expr.callee.object.name;
-                    const methodName = expr.callee.property.name;
-                    // F1 黑名单化 + F2：命名空间调用（<ns>.<op>() 裸调用，无赋值）——对象是 'cad'
-                    // 或顶层 import 绑定名（第三方命名空间调用）
-                    if (isNamespaceName(objName)) {
-                        const nsName = objName;
-                        const flags = { computed: false };
-                        const positional = parsePositionalArgs(expr.arguments, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, parseCode, `${nsName}.${methodName}() call`);
-                        const args = splitPositionalOptions(positional).named;
-                        const nsStmt = {
-                            id: asStmtId('__pending__'),
-                            callee: methodName,
-                            args,
-                            positional,
-                            outputs: [],
-                            hasAssignment: false,
-                            ...(nsName !== defaultNsName ? { namespace: nsName } : {}),
-                            ...(flags.computed ? { hasComputedArgs: true } : {}),
-                        };
-                        statements.push(nsStmt);
-                        statementLines.push(line);
-                        break;
-                    }
-                    // 成员方法调用：receiver 须已声明
-                    const targetVar = objName;
-                    // 验证 targetVar 已声明（变量作用域检查，非 op 知识）
-                    if (!varToId.has(targetVar)) {
-                        // Loose mode: external receiver passes through (append text may call
-                        // do_assemble() on an assembly created by an earlier statement).
-                        if (looseVars) {
-                            varToId.set(targetVar, asPartName(targetVar));
-                        }
-                        else {
-                            throw new ParseError(`unknown variable "${targetVar}" in .${methodName}() call`, line, 'E_REFERENCE');
-                        }
-                    }
-                    const flags = { computed: false };
-                    const positional = parsePositionalArgs(expr.arguments, paramNames, paramValues, varToId, nsNames, defaultNsName, line, flags, looseVars, parseCode, `.${methodName}() call`);
-                    const args = splitPositionalOptions(positional).named;
-                    const memberStmt = {
-                        id: asStmtId('__pending__'),
-                        callee: methodName,
-                        args,
-                        positional,
-                        outputs: [],
-                        receiver: targetVar,
-                        hasAssignment: false,
-                        ...(flags.computed ? { hasComputedArgs: true } : {}),
-                    };
-                    statements.push(memberStmt);
-                    statementLines.push(line);
-                    break;
-                }
-                // 其余裸表达式语句：黑名单化后仍拒绝（无意义的表达式）
-                throw new ParseError(`bare expression statements not allowed; use 'const part0 = cad.op(...)' instead`, line, 'E_STATEMENT');
-            }
-            default:
-                throwUnsupportedStatement(stmtNode, line);
-        }
-    }
-    // ── 3.5 独立 StmtId 分配 + 引用收集（Phase 3: id = sN） ──
-    // StmtId 按语句顺序分配 s(K+1)..s(K+N)，K = params.length——参数在编译产物中占 s1..sK，
-    // 使 parser 分配的 id 与 compileToModule 生成的模块语句 id 一致。
-    const stmtIdBase = params.length;
-    let stmtIdx = 0;
-    for (const stmt of statements) {
-        const sN = asStmtId(`s${stmtIdBase + (++stmtIdx)}`);
-        stmt.id = sN;
-        stmt.refs = collectStatementRefs(stmt);
-    }
-    const sourceLines = lineOffset ? statementLines.map((l) => l - lineOffset) : statementLines;
-    // ── 4. terminal shapes ──
-    // Phase 3：终端判定移入执行收尾（runtime.collectResult），parser 不再计算。
-    // 显式 return [...] 的 terminalShapes 优先；否则运行期从 result.outputs 过滤。
-    const finalTerminalShapes = terminalShapes;
-    // ── 5. 构建 ScriptIR ──
-    const script = {
-        params,
-        statements,
-        ...(scriptImports.length > 0 ? { imports: scriptImports } : {}),
-        ...(functions.length > 0 ? { functions } : {}),
-        meta,
-        terminalShapes: finalTerminalShapes,
-    };
-    return { script, varToId, statementLines: sourceLines };
-}
-// ── 字面量解析（仅允许字面量，不允许标识符/调用） ──
-function parseLiteralOnly(node, line) {
-    switch (node.type) {
-        case 'Literal':
-            return node.value;
-        case 'ArrayExpression':
-            return node.elements.map((el) => parseLiteralOnly(el, line));
-        case 'ObjectExpression': {
-            const obj = {};
-            for (const prop of node.properties) {
-                const key = prop.key?.type === 'Identifier' ? prop.key.name
-                    : prop.key?.type === 'Literal' ? String(prop.key.value)
-                        : null;
-                if (!key)
-                    throw new ParseError('invalid object key in param literal', line);
-                obj[key] = parseLiteralOnly(prop.value, line);
-            }
-            return obj;
-        }
-        case 'UnaryExpression':
-            if (node.operator === '-' && node.argument?.type === 'Literal') {
-                return -node.argument.value;
-            }
-            throw new ParseError(`unsupported unary in param literal`, line);
-        default:
-            throw new ParseError(`param value must be a literal (number/string/boolean/null/array/object), got ${node.type}`, line);
-    }
-}
-// ── 版本迁移 ──
-/**
- * Read the `// apiVersion: N` declaration from the top of a faijs source text,
- * defaulting to 1 when absent.
- * @param code - the faijs source text to inspect.
- * @returns the declared API version number, or 1 when none is present.
- */
-export function getApiVersion(code) {
-    const match = code.match(/^\/\/\s*apiVersion:\s*(\d+)/m);
-    return match ? parseInt(match[1], 10) : 1;
-}
-//# sourceMappingURL=parser.js.map