@faicad/faijs 0.13.0

package/dist/lang/metadata-extractor.js

@@ -0,0 +1,1377 @@
+/**
+ * metadata-extractor — 无 IR 元数据提取器（UI 通道语义源）
+ *
+ * 方案：docs/plans/2026-09-06-no-ir-dual-channel-runtime.md §4.1（D3）
+ *
+ * 定位：从 .fai.js 源码（任意合法 JS）提取 **UI 通道需要的全部元数据**。
+ * 输入 = 源码文本；输出 = UiMetadata。不生成可执行代码、不求值、不参与执行、
+ * 不建执行中介 IR（已删除，只产宿主面类型）。
+ *
+ * lines 面 = StatementSummary[]（与现状 analyzeCode 产出逐字相等，A-16 对拍
+ * 锁定；唯一语义差异：id = `'s' + lineNo`，append 场景稳定）。行分类：
+ * op 行 → lines；param 行 → params；import 行 → imports；function 行 →
+ * functions；循环/条件/switch 块 → blocks（只读节点，不分析内部语义，R8）。
+ *
+ * 本文件不 import parser.ts/compile.ts（P6 删除 IR 后唯一存活解析侧）。
+ */
+import { parse as acornParse } from 'acorn';
+import { asStmtId, asPartName } from '../identity.js';
+import { isHostVarRef, isHostParamRef, isHostCallRef, isHostExprRef } from './host-arg.js';
+import { ParseError } from './parse-error.js';
+import { fnv1a32 } from './fnv-hash.js';
+import { assertSecure } from './security-scanner.js';
+const CONTROL_FLOW_TYPES = new Set([
+    'IfStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement',
+    'WhileStatement', 'DoWhileStatement', 'SwitchStatement', 'TryStatement',
+    'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'LabeledStatement',
+    'WithStatement', 'BlockStatement',
+]);
+function lineOf(node) {
+    return node?.loc?.start?.line ?? 1;
+}
+function derivePackageName(specifier) {
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+    }
+    return specifier.split('/')[0];
+}
+function numFold(v, usedParam = false) {
+    return Number.isFinite(v) ? { ok: true, value: v, usedParam } : { ok: false };
+}
+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;
+}
+function tryFoldConstExpr(node, symbols) {
+    switch (node.type) {
+        case 'Literal':
+            return { ok: true, value: node.value, usedParam: false };
+        case 'Identifier': {
+            if (!symbols.paramNames.has(node.name))
+                return { ok: false };
+            const v = symbols.paramValues.get(node.name);
+            return v === undefined ? { ok: false } : { ok: true, value: v, usedParam: true };
+        }
+        case 'UnaryExpression': {
+            const operand = tryFoldConstExpr(node.argument, symbols);
+            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, symbols);
+            if (!left.ok)
+                return { ok: false };
+            const right = tryFoldConstExpr(node.right, symbols);
+            if (!right.ok)
+                return { ok: false };
+            const a = left.value;
+            const b = right.value;
+            const usedParam = left.usedParam || right.usedParam;
+            const numBin = (op) => typeof a === 'number' && typeof b === 'number' ? numFold(op(a, b), usedParam) : { ok: false };
+            const cmpBin = (op) => {
+                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 };
+            };
+            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((x, y) => x - y);
+                case '*': return numBin((x, y) => x * y);
+                case '/': return numBin((x, y) => x / y);
+                case '%': return numBin((x, y) => x % y);
+                case '**': return numBin((x, y) => x ** y);
+                case '<': return cmpBin((x, y) => x < y);
+                case '<=': return cmpBin((x, y) => x <= y);
+                case '>': return cmpBin((x, y) => x > y);
+                case '>=': return cmpBin((x, y) => x >= y);
+                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 };
+            }
+        }
+        case 'LogicalExpression': {
+            const left = tryFoldConstExpr(node.left, symbols);
+            if (!left.ok)
+                return { ok: false };
+            const right = tryFoldConstExpr(node.right, symbols);
+            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], symbols);
+                    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, symbols);
+            if (!test.ok)
+                return { ok: false };
+            const chosen = tryFoldConstExpr(test.value ? node.consequent : node.alternate, symbols);
+            if (!chosen.ok)
+                return { ok: false };
+            return { ok: true, value: chosen.value, usedParam: test.usedParam || chosen.usedParam };
+        }
+        default:
+            return { ok: false };
+    }
+}
+// ── Expr 白名单（与现状 parser.isExprWhitelist 同构） ──
+//
+// 本函数与 collectExprIdentifiers 是「唯一实现」——expr-validate.ts / source-edit.ts
+// 直接 import 复用，不复制（见 plans/2026-09-08-timeline-param-expression-editing.md §3.4.1）。
+/**
+ * <Ns>.fn(...) 等「白名单表达式」结构判定（无可选链、无 spread、成员非计算）。
+ * @param node 待判定的表达式 AST 节点；nil 或非法输入按非白名单处理。
+ * @returns 节点自身及其全部子表达式均在白名单结构内 → true，否则 false。
+ */
+export 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':
+            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;
+    }
+}
+/**
+ * 递归收集表达式引用：参数 → params；已声明变量 → refs；未知 → E_REFERENCE。
+ *
+ * opts（可选扩展；缺省时行为与历史完全一致）：
+ * - `lenient: true`：未知标识符不抛错（静默跳过）——ArgSource 记录路径用，
+ *   保证提取本身绝不抛新错；
+ * - `defaultNs`：把默认命名空间（'cad'）视同 nsBindings 成员——`cad.faceNormal(p)`
+ *   作为参数槽整条记录时，不会把 'cad' 当作未知标识符。
+ *
+ * 本函数与 isExprWhitelist 是「唯一实现」——expr-validate.ts / source-edit.ts
+ * 直接 import 复用，不复制（见 plans/2026-09-08-timeline-param-expression-editing.md §3.4.1）。
+ *
+ * @param node 表达式的 AST 根节点；nil 或非对象直接返回。
+ * @param symbols 提取器符号表（判定 Identifier 是参数/已声明/未知）。
+ * @param line 当前语句行号（未知标识符报错时的行号）。
+ * @param params 收集命中参数名的输出集合。
+ * @param refs 收集命中已声明变量的输出集合。
+ * @param opts 可选扩展；`lenient` 静默跳过未知标识符，`defaultNs` 把默认命名空间视同绑定成员。
+ */
+export function collectExprIdentifiers(node, symbols, line, params, refs, opts) {
+    if (!node || typeof node !== 'object')
+        return;
+    switch (node.type) {
+        case 'Identifier': {
+            const name = node.name;
+            if (symbols.paramNames.has(name)) {
+                params.add(name);
+            }
+            else if (symbols.declared.has(name)) {
+                refs.add(name);
+            }
+            else if (opts?.lenient === true) {
+                // lenient：未知标识符跳过（ArgSource 记录路径，保证提取不抛新错）
+            }
+            else {
+                throw new ParseError(`unknown identifier "${name}" in expression`, line, 'E_REFERENCE');
+            }
+            return;
+        }
+        case 'UnaryExpression':
+            collectExprIdentifiers(node.argument, symbols, line, params, refs, opts);
+            return;
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            collectExprIdentifiers(node.left, symbols, line, params, refs, opts);
+            collectExprIdentifiers(node.right, symbols, line, params, refs, opts);
+            return;
+        case 'ConditionalExpression':
+            collectExprIdentifiers(node.test, symbols, line, params, refs, opts);
+            collectExprIdentifiers(node.consequent, symbols, line, params, refs, opts);
+            collectExprIdentifiers(node.alternate, symbols, line, params, refs, opts);
+            return;
+        case 'ArrayExpression':
+            for (const el of node.elements)
+                collectExprIdentifiers(el, symbols, line, params, refs, opts);
+            return;
+        case 'ObjectExpression':
+            for (const prop of node.properties) {
+                if (prop?.type !== 'Property')
+                    continue;
+                collectExprIdentifiers(prop.value, symbols, line, params, refs, opts);
+            }
+            return;
+        case 'TemplateLiteral':
+            for (const expr of node.expressions)
+                collectExprIdentifiers(expr, symbols, line, params, refs, opts);
+            return;
+        case 'MemberExpression': {
+            // 命名空间绑定（import * as cfg / 模块命名空间）的成员 cfg.OutX：对象名是外部
+            // 命名空间，不收集为变量引用（§4.1 HostArg 引用形态；求值在内部 ctx.cfg 侧）。
+            // opts.defaultNs（缺省命名空间 'cad'）同样跳过——cad.faceNormal(p) 整条作为
+            // 参数槽记录时不会把 'cad' 当未知标识符。
+            const obj = node.object;
+            if (obj?.type === 'Identifier' && (symbols.nsBindings.has(obj.name) || obj.name === opts?.defaultNs)) {
+                if (node.computed)
+                    collectExprIdentifiers(node.property, symbols, line, params, refs, opts);
+                return;
+            }
+            collectExprIdentifiers(node.object, symbols, line, params, refs, opts);
+            if (node.computed)
+                collectExprIdentifiers(node.property, symbols, line, params, refs, opts);
+            return;
+        }
+        case 'CallExpression':
+            collectExprIdentifiers(node.callee, symbols, line, params, refs, opts);
+            for (const a of node.arguments) {
+                collectExprIdentifiers(a.type === 'SpreadElement' ? a.argument : a, symbols, line, params, refs, opts);
+            }
+            return;
+        default:
+            return;
+    }
+}
+/** 是否非平凡表达式：非 Literal（负字面量视为字面量）→ UI 显示 fx 徽标 */
+function isExpressionNode(node) {
+    if (!node || node.type === 'Literal')
+        return false;
+    if (node.type === 'UnaryExpression' && node.operator === '-' && node.argument?.type === 'Literal')
+        return false;
+    return true;
+}
+/**
+ * 在折叠之前记录一条参数槽（ArgSource）。
+ *
+ * - start/end 相对 extractMetadata 的入参 code（减 codeOffset，含封装归一化）；
+ * - text = parseCode 原文切片（E_RANGE_STALE 用 `code.slice(start,end) === text` 断言）；
+ * - params/refs 用 collectExprIdentifiers 的 lenient 模式（未知标识符跳过，
+ *   保证提取不抛新错——与 main parse 的 E_REFERENCE 例外保持解耦）。
+ */
+function recordArgSource(node, ctx, path) {
+    if (!node || typeof node !== 'object' || node.start == null || node.end == null || node.end < node.start)
+        return;
+    const isExpr = isExpressionNode(node);
+    const params = new Set();
+    const refs = new Set();
+    if (isExpr) {
+        collectExprIdentifiers(node, ctx.symbols, lineOf(node), params, refs, {
+            lenient: true,
+            defaultNs: ctx.symbols.defaultNsName,
+        });
+    }
+    ctx.argSources.push({
+        stmtId: ctx.stmtId,
+        path,
+        text: ctx.sourceText.slice(node.start, node.end),
+        start: node.start - ctx.codeOffset,
+        end: node.end - ctx.codeOffset,
+        params: [...params],
+        refs: [...refs],
+        isExpression: isExpr,
+    });
+}
+function parseValueExpr(node, ctx, path) {
+    if (!node)
+        throw new ParseError('missing value expression', 1, 'E_VALUE');
+    const line = lineOf(node);
+    // P0-B：在折叠之前记录一条 ArgSource（path === null 忽略——参数行 RHS 由
+    // recordArgSource 显式记录，不再双记）。
+    if (path !== null)
+        recordArgSource(node, ctx, path);
+    // 折叠优先：Unary/Binary/Logical/Template/Conditional 可静态折叠（字面量 + 参数）
+    if (node.type === 'UnaryExpression' ||
+        node.type === 'BinaryExpression' ||
+        node.type === 'LogicalExpression' ||
+        node.type === 'TemplateLiteral' ||
+        node.type === 'ConditionalExpression') {
+        const r = tryFoldConstExpr(node, ctx.symbols);
+        if (r.ok) {
+            // F1-E1：仅折叠表达式引用参数才标 computed；纯字面量（负字面量）不标
+            if (r.usedParam)
+                ctx.computed.value = true;
+            return r.value;
+        }
+        // 折叠失败且 ∈ 白名单 → expr-ref（运行时求值）
+        if (isExprWhitelist(node)) {
+            const params = new Set();
+            const refs = new Set();
+            collectExprIdentifiers(node, ctx.symbols, line, params, refs);
+            ctx.computed.value = true;
+            return {
+                kind: 'expr-ref',
+                text: ctx.sourceText.slice(node.start, node.end),
+                refs: [...refs],
+                params: [...params],
+            };
+        }
+        throw new ParseError(`cannot statically evaluate ${node.type} in args (must reference declared params or literals)`, line, 'E_VALUE');
+    }
+    switch (node.type) {
+        case 'Literal':
+            return node.value;
+        case 'Identifier': {
+            const name = node.name;
+            if (ctx.symbols.paramNames.has(name)) {
+                return { kind: 'param-ref', name };
+            }
+            if (ctx.symbols.declared.has(name)) {
+                return { kind: 'var-ref', name };
+            }
+            if (ctx.looseVars) {
+                ctx.symbols.declared.add(name);
+                return { kind: 'var-ref', name };
+            }
+            throw new ParseError(`unknown identifier "${name}" in args value (not a declared param or variable)`, line, 'E_REFERENCE');
+        }
+        case 'ArrayExpression': {
+            const out = [];
+            for (let i = 0; i < node.elements.length; i++) {
+                const el = node.elements[i];
+                if (el === null || el === undefined) {
+                    throw new ParseError('array holes are not supported in args', line, 'E_VALUE');
+                }
+                const childPath = path === null ? null : `${path}[${i}]`;
+                if (el.type === 'SpreadElement') {
+                    if (childPath !== null)
+                        recordArgSource(el.argument, ctx, childPath);
+                    const r = tryFoldConstExpr(el.argument, ctx.symbols);
+                    if (!r.ok || !Array.isArray(r.value)) {
+                        throw new ParseError('cannot statically evaluate spread in args (expected an array param or literal)', line, 'E_VALUE');
+                    }
+                    ctx.computed.value = true;
+                    out.push(...r.value);
+                    continue;
+                }
+                out.push(parseValueExpr(el, ctx, childPath));
+            }
+            return out;
+        }
+        case 'ObjectExpression':
+            return parseObjectValue(node, ctx, path);
+        case 'CallExpression': {
+            const callee = node.callee;
+            // <ns>.<fn>(...) → call-ref（只读查询）
+            if (callee?.type === 'MemberExpression' &&
+                callee.object?.type === 'Identifier' &&
+                (ctx.symbols.nsBindings.has(callee.object.name) ||
+                    callee.object.name === ctx.symbols.defaultNsName) &&
+                callee.property?.type === 'Identifier') {
+                const nsName = callee.object.name;
+                const args = node.arguments.map((a, i) => parseValueExpr(a, ctx, path === null ? null : `${path}[${i}]`));
+                const callRef = {
+                    kind: 'call-ref',
+                    callee: callee.property.name,
+                    args,
+                    ...(nsName !== ctx.symbols.defaultNsName ? { namespace: nsName } : {}),
+                };
+                return callRef;
+            }
+            if (isExprWhitelist(node)) {
+                const params = new Set();
+                const refs = new Set();
+                collectExprIdentifiers(node, ctx.symbols, line, params, refs);
+                ctx.computed.value = true;
+                return {
+                    kind: 'expr-ref',
+                    text: ctx.sourceText.slice(node.start, node.end),
+                    refs: [...refs],
+                    params: [...params],
+                };
+            }
+            throw new ParseError('nested calls in args must be <ns>.<ident>(...) or a whitelisted expression', line, 'E_VALUE');
+        }
+        case 'MemberExpression': {
+            if (isExprWhitelist(node)) {
+                const params = new Set();
+                const refs = new Set();
+                collectExprIdentifiers(node, ctx.symbols, line, params, refs);
+                ctx.computed.value = true;
+                return {
+                    kind: 'expr-ref',
+                    text: ctx.sourceText.slice(node.start, node.end),
+                    refs: [...refs],
+                    params: [...params],
+                };
+            }
+            throw new ParseError('unsupported member expression in args: optional chaining is not allowed', line, 'E_VALUE');
+        }
+        default:
+            throw new ParseError(`unsupported value expression: ${node.type}`, line, 'E_VALUE');
+    }
+}
+/** 对象字面量参数解析 + 参数槽记录（属性值路径 = `<base>.<key>`；shorthand 以来源名为 text 记一条）。 */
+function parseObjectValue(node, ctx, path) {
+    const line = lineOf(node);
+    const obj = {};
+    for (const prop of node.properties) {
+        if (prop.type === 'SpreadElement') {
+            const r = tryFoldConstExpr(prop.argument, ctx.symbols);
+            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');
+            }
+            ctx.computed.value = true;
+            Object.assign(obj, r.value);
+            continue;
+        }
+        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');
+        if (prop.shorthand) {
+            // shorthand { size } → { size: param-ref }；已声明变量 shorthand 现状报 E_REFERENCE
+            const name = key;
+            let slotParams = [];
+            let slotRefs = [];
+            if (ctx.symbols.paramNames.has(name)) {
+                obj[key] = { kind: 'param-ref', name };
+                slotParams = [name];
+            }
+            else if (ctx.looseVars) {
+                ctx.symbols.declared.add(name);
+                obj[key] = { kind: 'var-ref', name };
+                slotRefs = [name];
+            }
+            else {
+                throw new ParseError(`unknown shorthand identifier "${key}" (not a declared param)`, line, 'E_REFERENCE');
+            }
+            // P0-B：shorthand 槽（以属性名 == 变量名作 text，path = <base>.<key>，isExpression=false）
+            if (path !== null) {
+                ctx.argSources.push({
+                    stmtId: ctx.stmtId,
+                    path: `${path}.${key}`,
+                    text: ctx.sourceText.slice(prop.start, prop.end),
+                    start: prop.start - ctx.codeOffset,
+                    end: prop.end - ctx.codeOffset,
+                    params: slotParams,
+                    refs: slotRefs,
+                    isExpression: false,
+                });
+            }
+        }
+        else {
+            obj[key] = parseValueExpr(prop.value, ctx, path === null ? null : `${path}.${key}`);
+        }
+    }
+    return obj;
+}
+/** 位置实参解析（与现状 parsePositionalArgs 同构）；P0-B 附带参数槽记录（pathBase 缺省 'positional'）。 */
+function parsePositionalArgs(argNodes, ctx, line, pathBase = 'positional') {
+    const out = [];
+    for (let i = 0; i < argNodes.length; i++) {
+        const argNode = argNodes[i];
+        const isLast = i === argNodes.length - 1;
+        const isTrailingOptions = isLast && argNode?.type === 'ObjectExpression';
+        if (isTrailingOptions) {
+            // 尾随选项对象：只按 'args.<key>' 记录属性值，不把整对象再记一个 positional 槽
+            out.push(parseObjectValue(argNode, ctx, 'args'));
+            continue;
+        }
+        const slotPath = `${pathBase}[${i}]`;
+        if (argNode.type === 'Identifier') {
+            recordArgSource(argNode, ctx, slotPath);
+            const name = argNode.name;
+            if (ctx.symbols.declared.has(name)) {
+                out.push({ kind: 'var-ref', name });
+                continue;
+            }
+            if (ctx.looseVars) {
+                ctx.symbols.declared.add(name);
+                out.push({ kind: 'var-ref', name });
+                continue;
+            }
+            throw new ParseError(`unknown variable "${name}" in inputs`, lineOf(argNode), 'E_REFERENCE');
+        }
+        if (argNode.type === 'SpreadElement') {
+            recordArgSource(argNode.argument, ctx, slotPath);
+            const r = tryFoldConstExpr(argNode.argument, ctx.symbols);
+            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');
+            }
+            ctx.computed.value = true;
+            out.push(...r.value);
+            continue;
+        }
+        out.push(parseValueExpr(argNode, ctx, slotPath));
+    }
+    return out;
+}
+// ── 行摘要组装 ──
+/** 位置实参末位是否为纯数据对象（非引用形态）→ args 投影真源。
+ *  与现状 splitPositionalOptions 同构：引用形态 = var-ref/param-ref/call-ref/expr-ref
+ *  （kind 值 ∈ HOST_REF_KINDS 且完整匹配变体形状）；字面量对象的 kind 字段是普通数据。 */
+function isPlainDataObject(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        !Array.isArray(v) &&
+        !isHostVarRef(v) &&
+        !isHostParamRef(v) &&
+        !isHostCallRef(v) &&
+        !isHostExprRef(v));
+}
+/**
+ * 从单条调用组装 StatementSummary：
+ * - positional = 全量位置实参（末位纯对象保留，与现状一致）
+ * - args = 末位纯对象的投影（keep/keepHidden 键原样保留——compile 期才剥离）
+ */
+function buildLineSummary(spec) {
+    const last = spec.positional[spec.positional.length - 1];
+    const args = isPlainDataObject(last) ? { ...last } : {};
+    const refs = new Set();
+    for (const a of spec.positional)
+        collectRefsFromHostArg(a, refs);
+    if (spec.receiver !== undefined)
+        refs.add(spec.receiver);
+    const summary = {
+        id: asStmtId(`s${spec.line}`),
+        callee: spec.callee,
+        ...(spec.local
+            ? { local: true }
+            : spec.namespace !== undefined
+                ? {
+                    namespace: spec.namespace,
+                    ...(spec.ctx.symbols.nsBindings.get(spec.namespace) !== undefined
+                        ? { packageName: spec.ctx.symbols.nsBindings.get(spec.namespace) }
+                        : {}),
+                }
+                : {}),
+        ...(spec.receiver !== undefined ? { receiver: asPartName(spec.receiver) } : {}),
+        positional: spec.positional,
+        args,
+        outputs: spec.outputs.map((o) => asPartName(o)),
+        ...(spec.outputKeys !== undefined ? { outputKeys: spec.outputKeys } : {}),
+        hasAssignment: spec.hasAssignment,
+        hasComputedArgs: spec.ctx.computed.value,
+        line: spec.line,
+    };
+    if (refs.size > 0)
+        summary.refs = [...refs];
+    else
+        summary.refs = [];
+    return summary;
+}
+function collectRefsFromHostArg(value, out) {
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return;
+    const kind = value.kind;
+    if (kind === 'var-ref') {
+        out.add(value.name);
+        return;
+    }
+    if (kind === 'param-ref') {
+        out.add(value.name);
+        return;
+    }
+    if (kind === 'call-ref') {
+        for (const a of value.args)
+            collectRefsFromHostArg(a, out);
+        return;
+    }
+    if (kind === 'expr-ref') {
+        const e = value;
+        for (const p of e.params)
+            out.add(p);
+        for (const r of e.refs)
+            out.add(r);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const v of value)
+            collectRefsFromHostArg(v, out);
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const v of Object.values(value))
+            collectRefsFromHostArg(v, out);
+    }
+}
+// ── return / meta 解析 ──
+function parseReturnStatement(node, ctx) {
+    const line = lineOf(node);
+    const arg = node.argument;
+    if (!arg)
+        return {};
+    const resolveVar = (idNode) => {
+        if (idNode?.type !== 'Identifier')
+            throw new ParseError('unknown variable in return', line);
+        const name = idNode.name;
+        if (!ctx.symbols.declared.has(name) && !ctx.symbols.paramNames.has(name)) {
+            throw new ParseError(`unknown variable "${name}" in return`, line);
+        }
+        return asPartName(name);
+    };
+    const parseOne = (objNode) => {
+        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')
+                    id = resolveVar(prop.value);
+            }
+            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 };
+    };
+    if (arg.type === 'Identifier')
+        return { terminalShapes: [{ id: resolveVar(arg) }] };
+    if (arg.type === 'ObjectExpression') {
+        const r = parseOne(arg);
+        return { meta: r.meta, terminalShapes: r.id !== null ? [{ id: r.id, meta: r.meta }] : undefined };
+    }
+    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 r = parseOne(elem);
+            if (r.id)
+                terminalShapes.push({ id: r.id, meta: r.meta });
+        }
+        if (terminalShapes.length === 0)
+            throw new ParseError('return array must have at least one element', line);
+        return { terminalShapes };
+    }
+    throw new ParseError(`unsupported return expression: ${arg.type}`, line);
+}
+// ── keep 指令提取（行级 keep/keepHidden → metadata.keep） ──
+function extractKeepEntries(positional, line, symbols) {
+    const last = positional[positional.length - 1];
+    if (!isPlainDataObject(last))
+        return;
+    const entries = [];
+    const keepArg = last.keep;
+    if (Array.isArray(keepArg)) {
+        for (const entry of keepArg) {
+            const parsed = parseKeepEntry(entry);
+            if (parsed)
+                entries.push(parsed);
+        }
+    }
+    const statementDefault = last.keepHidden === true;
+    const normalized = entries.map((e) => {
+        // e.hidden 为显式 hidden 值（undefined → 未指定）；未指定时用语句级 keepHidden 兜底
+        return { target: e.target, hidden: e.hidden ?? statementDefault };
+    });
+    if (normalized.length > 0) {
+        const list = symbols.keep.get(line) ?? [];
+        list.push(...normalized);
+        symbols.keep.set(line, list);
+    }
+}
+function parseKeepEntry(entry) {
+    // 与现状 keep.ts parseKeepEntry 同构：字符串条目 / 裸 var-ref 条目不携带 hidden
+    // （语句级 keepHidden 兜底）；{ shape, hidden } 显式条目携带 hidden（false 也显式）。
+    if (typeof entry === 'string')
+        return { target: entry };
+    if (entry !== null && typeof entry === 'object' && !Array.isArray(entry)) {
+        const obj = entry;
+        const shape = obj.shape;
+        if (typeof shape === 'string')
+            return { target: shape, hidden: obj.hidden === true };
+        if (shape !== null && typeof shape === 'object') {
+            const s = shape;
+            if (s.kind === 'var-ref' && typeof s.name === 'string') {
+                return { target: s.name, hidden: obj.hidden === true };
+            }
+        }
+        const self = entry;
+        // 顶层 var-ref 条目（keep: [part0] → part0 是 var-ref 形态）：不携带 hidden
+        if (self.kind === 'var-ref' && typeof self.name === 'string') {
+            return { target: self.name };
+        }
+    }
+    return undefined;
+}
+/**
+ * 从源码文本提取 UI 通道元数据（UiMetadata）。
+ *
+ * 兼容面：analyzeCode/codeToArgs 实现建立在本函数之上（statement-summary.ts /
+ * code-to-args.ts），lines 面与 MetadataExtractor 投影逐字相等（A-16 对拍，
+ * id 兼容 's'+lineNo 规则：其余字段逐字相等）。不参与执行、不生成可执行代码。
+ *
+ * 行号语义与 MetadataExtractor 完全一致：
+ * - 容器代码（含 export default）→ 取容器箭头函数体，行号 = 原文行号；
+ * - 扁平代码 → 按 MetadataExtractor 同款封装（import 段提升到 export default 之外，
+ *   `export default async (ns) => {\n...` 包裹），行号扣封装偏移后 = analyzeCode
+ *   报告的 line。
+ *
+ * @param code - the .fai.js source text.
+ * @param options - optional extraction options.
+ * @returns the full UI metadata surface.
+ * @throws ParseError — 含行号（analyzeCode 抛错契约不变）。
+ */
+export function extractMetadata(code, options) {
+    // A1：安全门禁前置——在 acornParse 之前对原始 code 扫描，行号与用户编辑器一致。
+    // security 与 looseVars 正交：安全规则不受 looseVars 影响。
+    assertSecure(code, {
+        policy: options?.security ?? 'strict',
+        knownNames: [options?.defaultNs ?? 'cad', ...(options?.namespaces ?? [])],
+        ...(options?.nsNames ? { nsNames: options.nsNames } : {}),
+        defaultNs: options?.defaultNs,
+    });
+    const defaultNsName = options?.defaultNs ?? 'cad';
+    // 符号表（每行提取共享：参数名/值、已声明变量、命名空间绑定、函数集、keep 表）
+    const symbols = {
+        paramNames: new Set(),
+        paramValues: new Map(),
+        declared: new Set(),
+        nsBindings: new Map(),
+        localFnParams: new Map(),
+        defaultNsName,
+        keep: new Map(),
+    };
+    // ── 0. 顶层 import 预扫描（与 MetadataExtractor 同构；容器/扁平都允许头部 import） ──
+    let importBlock = null;
+    {
+        const seen = [];
+        try {
+            const prescan = acornParse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true, ranges: true });
+            for (const n of prescan.body) {
+                if (n.type === 'ImportDeclaration')
+                    seen.push(n);
+            }
+        }
+        catch {
+            // 原始文本非合法 module（如含 return）→ 交给主解析报错
+        }
+        if (seen.length > 0) {
+            const first = seen[0];
+            if (!onlyWhitespaceAndComments(code.slice(0, first.start))) {
+                throw new ParseError('import statements must appear as a contiguous block at the top of the file', lineOf(first) ?? 1, 'E_IMPORT');
+            }
+            for (let i = 1; i < seen.length; i++) {
+                const gap = code.slice(seen[i - 1].end, seen[i].start);
+                if (!onlyWhitespaceAndComments(gap)) {
+                    throw new ParseError('import statements must be contiguous (no statements between imports)', lineOf(seen[i]) ?? 1, 'E_IMPORT');
+                }
+            }
+            importBlock = { start: seen[0].start, end: seen[seen.length - 1].end };
+        }
+    }
+    // ── 0.5 扁平代码封装（与 MetadataExtractor 逐字同款；容器零封装） ──
+    // lineOffset：封装头占用的行数（语句行号 = acorn loc 行号 − lineOffset）。
+    // codeOffset：封装头字符长度（函数体原文区间坐标换算；容器格式为 0）。
+    let parseCode = code;
+    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;
+            // 字符偏移 = 注入的 '\n'（importText 后）+ 封装头长度。原实现 29+len 少算 1
+            //（未计入 importText 与封装间的换行），导致 import 场景的区间坐标错位——
+            // bodyRange/ArgSource.start/end 等归一化要落到原 code 坐标。
+            codeOffset = 1 + `export default async (${defaultNsName}) => {\n`.length;
+        }
+        else {
+            parseCode = `export default async (${defaultNsName}) => {\n${code}\n}`;
+            lineOffset = 1;
+            codeOffset = `export default async (${defaultNsName}) => {\n`.length;
+        }
+    }
+    // ── 1. 主解析（acorn module） ──
+    let ast;
+    try {
+        ast = acornParse(parseCode, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            locations: true,
+            ranges: true,
+        });
+    }
+    catch (err) {
+        const syntaxErr = err;
+        const loc = syntaxErr.loc?.line ?? 1;
+        throw new ParseError(`SyntaxError: ${syntaxErr.message ?? String(err)}`, loc, 'E_SYNTAX');
+    }
+    // 顶层 import（模块级，封装外）→ ImportEntry 表
+    const imports = [];
+    for (const n of ast.body) {
+        if (n.type !== 'ImportDeclaration')
+            continue;
+        const imp = classifyImport(n);
+        imports.push(imp);
+        if (imp.kind === 'namespace' && imp.localName) {
+            symbols.nsBindings.set(imp.localName, imp.packageName ?? imp.localName);
+        }
+        if (imp.kind === 'named') {
+            for (const b of imp.bindings)
+                symbols.declared.add(b);
+        }
+    }
+    // 宿主显式提供的命名空间绑定（codeToArgs 单行提取场景）
+    for (const n of options?.namespaces ?? [])
+        symbols.nsBindings.set(n, n);
+    // 顶层 export default → 容器箭头函数体（封装文本下必存在）
+    const exportDecl = ast.body.find((n) => n.type === 'ExportDefaultDeclaration');
+    if (!exportDecl) {
+        throw new ParseError('missing `export default`', 1);
+    }
+    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}) => { ... }\``, lineOf(exportDecl));
+    }
+    const body = arrowFn.body;
+    if (body?.type !== 'BlockStatement') {
+        throw new ParseError('expected arrow function body to be a block statement { ... }', lineOf(arrowFn));
+    }
+    const bodyNodes = body.body;
+    // 顶层函数预扫描（本机函数集）
+    for (const n of bodyNodes) {
+        if (n.type === 'FunctionDeclaration' && n.id?.type === 'Identifier') {
+            const fparams = [];
+            for (const p of n.params ?? []) {
+                if (p?.type === 'Identifier')
+                    fparams.push(p.name);
+                else
+                    throw new ParseError('function params must be plain identifiers', lineOf(n), 'E_STATEMENT');
+            }
+            symbols.localFnParams.set(n.id.name, fparams);
+            symbols.declared.add(n.id.name);
+        }
+    }
+    const lines = [];
+    const params = [];
+    const functions = [];
+    const blocks = [];
+    let meta;
+    let terminalShapes;
+    // P0-B：参数槽记录累积（跨语句共享，语句顺序追加）
+    const argSources = [];
+    // ── 逐顶层语句分类 ──
+    for (const stmtNode of bodyNodes) {
+        const rawLine = lineOf(stmtNode);
+        const line = lineOffset ? rawLine - lineOffset : rawLine;
+        const vctx = {
+            symbols,
+            looseVars: options?.looseVars === true,
+            looseLocalCalls: options?.looseLocalCalls === true,
+            sourceText: parseCode,
+            computed: { value: false },
+            stmtId: asStmtId(`s${line}`),
+            codeOffset,
+            argSources,
+        };
+        switch (stmtNode.type) {
+            case 'ImportDeclaration':
+                break; // 已在顶部收集（封装文本下 import 不在此层）
+            case 'FunctionDeclaration': {
+                const name = stmtNode.id?.name;
+                const fparams = symbols.localFnParams.get(name) ?? [];
+                const bodyStart = stmtNode.body.start + 1 - codeOffset;
+                const bodyEnd = stmtNode.body.end - 1 - codeOffset;
+                const bodyText = parseCode.slice(stmtNode.body.start + 1, stmtNode.body.end - 1);
+                functions.push({
+                    name,
+                    lineNo: line,
+                    params: fparams,
+                    bodyRange: { start: bodyStart, end: bodyEnd },
+                    body: bodyText,
+                    bodyHash: fnv1a32(bodyText),
+                });
+                break;
+            }
+            case 'VariableDeclaration': {
+                if (stmtNode.kind !== 'const' && stmtNode.kind !== 'let') {
+                    throw new ParseError(`only 'const' or 'let' declarations allowed, got '${stmtNode.kind}'`, line, 'E_STATEMENT');
+                }
+                for (const decl of stmtNode.declarations) {
+                    const dline = lineOf(decl);
+                    const dlineSrc = lineOffset ? dline - lineOffset : dline;
+                    // 解构 op 行
+                    if (decl.id?.type === 'ObjectPattern') {
+                        const summary = classifyDestructure(decl, dlineSrc, vctx);
+                        lines.push(summary);
+                        for (const out of summary.outputs)
+                            symbols.declared.add(String(out));
+                        continue;
+                    }
+                    if (decl.id?.type !== 'Identifier') {
+                        throw new ParseError('expected identifier on left side of const declaration', dlineSrc, 'E_STATEMENT');
+                    }
+                    const name = decl.id.name;
+                    let init = decl.init;
+                    if (init?.type === 'AwaitExpression')
+                        init = init.argument;
+                    if (init?.type === 'ImportExpression') {
+                        throw new ParseError('dynamic import() is not allowed in faijs (no control flow)', dlineSrc, 'E_CONTROL_FLOW');
+                    }
+                    // op 行：const x = <ns>.<op>(...) / <localFn>(...)
+                    if (init?.type === 'CallExpression' && isOpCallCallee(init, vctx)) {
+                        const summary = classifyOpCall(init, dlineSrc, vctx, { output: name, hasAssignment: true });
+                        lines.push(summary);
+                        symbols.declared.add(name);
+                        continue;
+                    }
+                    // P0-B：参数行 RHS 槽——整条 init 源码区间记一条
+                    //（path：单声明行 'rhs'；一行多参声明行 'rhs:<name>' 区分）。
+                    if (init) {
+                        const rhsPath = stmtNode.declarations.length > 1 ? `rhs:${name}` : 'rhs';
+                        recordArgSource(init, vctx, rhsPath);
+                    }
+                    // 参数行：const x = <literal> / <纯字面量折叠>（值已知）
+                    const isLiteral = init?.type === 'Literal' ||
+                        init?.type === 'ArrayExpression' ||
+                        init?.type === 'ObjectExpression';
+                    const isNegLiteral = init?.type === 'UnaryExpression' && init.operator === '-' && init.argument?.type === 'Literal';
+                    if (isLiteral || isNegLiteral) {
+                        const value = isNegLiteral
+                            ? -init.argument.value
+                            : isLiteralValue(init)
+                                ? parseLiteralValue(init)
+                                : parseValueExpr(init, vctx, null);
+                        const literalLike = isNegLiteral || init.type === 'Literal';
+                        params.push({
+                            name,
+                            lineNo: dlineSrc,
+                            value,
+                            type: typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'bool' : 'vec3',
+                            computed: !literalLike,
+                        });
+                        symbols.paramNames.add(name);
+                        symbols.declared.add(name);
+                        if (literalLike)
+                            symbols.paramValues.set(name, value);
+                        continue;
+                    }
+                    // 其余 const 形态：computed 参数（派生常量 / 引用表达式）——A-11 语法自由
+                    if (init) {
+                        params.push({ name, lineNo: dlineSrc, value: undefined, type: 'vec3', computed: true });
+                        symbols.declared.add(name);
+                        continue;
+                    }
+                    throw new ParseError(`unsupported const declaration: init type = ${init?.type ?? 'null'}`, line, 'E_STATEMENT');
+                }
+                break;
+            }
+            case 'ExpressionStatement': {
+                classifyExpression(stmtNode.expression, line, vctx, lines);
+                break;
+            }
+            case 'ReturnStatement': {
+                const r = parseReturnStatement(stmtNode, vctx);
+                meta = r.meta;
+                terminalShapes = r.terminalShapes;
+                break;
+            }
+            default: {
+                // 控制流/块 → 只读块节点（R8）
+                if (CONTROL_FLOW_TYPES.has(stmtNode.type)) {
+                    blocks.push({
+                        lineNo: line,
+                        kind: blockKind(stmtNode.type),
+                        astKind: stmtNode.type,
+                        source: parseCode.slice(stmtNode.start, stmtNode.end),
+                        range: { start: stmtNode.start - codeOffset, end: stmtNode.end - codeOffset },
+                    });
+                    break;
+                }
+                if (stmtNode.type === 'ClassDeclaration') {
+                    throw new ParseError('class declarations are not allowed in faijs', line, 'E_STATEMENT');
+                }
+                if (stmtNode.type === 'NewExpression') {
+                    throw new ParseError('"new" expressions are not allowed in faijs (new Function is a safety red line)', line, 'E_STATEMENT');
+                }
+                if (stmtNode.type === 'WithStatement') {
+                    throw new ParseError('"with" statements are not allowed in faijs (strict mode)', line, 'E_CONTROL_FLOW');
+                }
+                // 其余未知顶层语句 → 只读块
+                blocks.push({
+                    lineNo: line,
+                    kind: 'other',
+                    astKind: stmtNode.type,
+                    source: parseCode.slice(stmtNode.start, stmtNode.end),
+                    range: { start: stmtNode.start - codeOffset, end: stmtNode.end - codeOffset },
+                });
+                break;
+            }
+        }
+    }
+    // P0-B：名称集合 = 参数 ∪ 已声明变量 ∪ 命名空间绑定 ∪ 本地函数名（字典序去重）。
+    // 宿主把「参数表达式」中的未知标识符当作参数名（期望名）处理时用它做联想。
+    const names = [
+        ...new Set([
+            ...symbols.paramNames,
+            ...symbols.declared,
+            ...symbols.nsBindings.keys(),
+            ...symbols.localFnParams.keys(),
+        ]),
+    ].sort();
+    return { lines, params, imports, functions, blocks, keep: symbols.keep, meta, terminalShapes, argSources, names };
+}
+function isLiteralValue(init) {
+    return init.type === 'Literal';
+}
+/** 字面量（非数组/对象）直接取值。 */
+function parseLiteralValue(init) {
+    return init.value;
+}
+function countLines(text) {
+    if (text === '')
+        return 0;
+    return (text.match(/\n/g) ?? []).length + 1;
+}
+function onlyWhitespaceAndComments(text) {
+    return text
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/[^\n]*/g, '')
+        .trim() === '';
+}
+function blockKind(type) {
+    switch (type) {
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'ForOfStatement':
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+            return 'loop';
+        case 'IfStatement':
+            return 'condition';
+        case 'SwitchStatement':
+            return 'switch';
+        default:
+            return 'other';
+    }
+}
+function classifyImport(decl) {
+    const line = lineOf(decl);
+    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 specs = decl.specifiers ?? [];
+    if (specs.length === 0) {
+        throw new ParseError('side-effect imports are not supported (use import * as ns from "pkg")', line, 'E_IMPORT');
+    }
+    const first = specs[0];
+    if (first.type === 'ImportNamespaceSpecifier') {
+        return { lineNo: line, specifier, kind: 'namespace', bindings: [first.local?.name], localName: first.local?.name, packageName };
+    }
+    if (first.type === 'ImportDefaultSpecifier') {
+        return { lineNo: line, specifier, kind: 'default', bindings: [first.local?.name], localName: first.local?.name, packageName };
+    }
+    const bindings = specs.map((s) => s.local?.name);
+    return { lineNo: line, specifier, kind: 'named', bindings, localName: bindings[0], packageName };
+}
+/** init 是否为 op 调用 callee（<ns>.<op> / 裸本机函数）。 */
+function isOpCallCallee(init, ctx) {
+    const callee = init.callee;
+    if (callee?.type === 'MemberExpression') {
+        return (callee.object?.type === 'Identifier' &&
+            callee.property?.type === 'Identifier' &&
+            (ctx.symbols.nsBindings.has(callee.object.name) ||
+                callee.object.name === ctx.symbols.defaultNsName ||
+                ctx.symbols.declared.has(callee.object.name) ||
+                ctx.looseVars));
+    }
+    if (callee?.type === 'Identifier') {
+        return ctx.symbols.localFnParams.has(callee.name) || ctx.looseLocalCalls;
+    }
+    return false;
+}
+/** 从调用表达式构造 op 行（output 单输出 / 副作用无输出）。 */
+function classifyOpCall(call, line, vctx, opts) {
+    const calleeNode = call.callee;
+    let callee;
+    let namespace;
+    let local;
+    let receiver;
+    if (calleeNode?.type === 'MemberExpression' && calleeNode.object?.type === 'Identifier' && calleeNode.property?.type === 'Identifier') {
+        const objName = calleeNode.object.name;
+        if (vctx.symbols.nsBindings.has(objName) || objName === vctx.symbols.defaultNsName) {
+            namespace = objName === vctx.symbols.defaultNsName ? undefined : objName;
+            callee = calleeNode.property.name;
+        }
+        else {
+            receiver = objName;
+            callee = calleeNode.property.name;
+        }
+    }
+    else if (calleeNode?.type === 'Identifier') {
+        local = true;
+        callee = calleeNode.name;
+    }
+    else {
+        throw new ParseError('expected <ns>.<op>(...) or local function call', line, 'E_STATEMENT');
+    }
+    const positional = parsePositionalArgs(call.arguments ?? [], vctx, line);
+    const summary = buildLineSummary({
+        callee,
+        line,
+        ctx: vctx,
+        positional,
+        namespace,
+        local,
+        receiver,
+        outputs: opts.output !== undefined ? [opts.output] : [],
+        hasAssignment: opts.hasAssignment,
+    });
+    extractKeepEntries(positional, line, vctx.symbols);
+    attachAssemblySummary(summary);
+    return summary;
+}
+/**
+ * P2-f4：装配语句摘要附加（cad.assembly / asmN.do_assemble / asmN.solve）。
+ *
+ * - `cad.assembly`（缺省命名空间，namespace===undefined）→ isAssembly + assembly 摘要。
+ *   摘要只含 {name?, memberCount, constraintTypes}；约束全文不提取（宿主 args 通道
+ *   保留，model-store.ts:973 继续从 structuralStmtArgs(stmt).constraints 取）。
+ * - `asmN.do_assemble` / `asmN.solve`（receiver 调用）→ isAssembly（装配行为语句）。
+ */
+function attachAssemblySummary(summary) {
+    if (summary.callee === 'assembly' && summary.namespace === undefined) {
+        const members = summary.args.members;
+        const constraints = summary.args.constraints;
+        if (!Array.isArray(members) || !Array.isArray(constraints))
+            return;
+        const constraintTypes = [];
+        for (const c of constraints) {
+            if (c && typeof c === 'object' && typeof c.type === 'string') {
+                constraintTypes.push(c.type);
+            }
+        }
+        const name = summary.args.name;
+        summary.isAssembly = true;
+        summary.assembly = {
+            ...(typeof name === 'string' ? { name } : {}),
+            memberCount: members.length,
+            constraintTypes,
+        };
+        return;
+    }
+    if ((summary.callee === 'do_assemble' || summary.callee === 'solve') && summary.receiver !== undefined) {
+        summary.isAssembly = true;
+    }
+}
+/** 从解构调用构造 op 行（const { k1: v1, k2 } = <ns>.<op>(...)）。 */
+function classifyDestructure(decl, line, vctx) {
+    const props = decl.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);
+    }
+    let init = decl.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 calleeNode = init.callee;
+    let callee;
+    let namespace;
+    let local;
+    let receiver;
+    if (calleeNode?.type === 'MemberExpression' && calleeNode.object?.type === 'Identifier' && calleeNode.property?.type === 'Identifier') {
+        const objName = calleeNode.object.name;
+        if (vctx.symbols.nsBindings.has(objName) || objName === vctx.symbols.defaultNsName) {
+            namespace = objName === vctx.symbols.defaultNsName ? undefined : objName;
+            callee = calleeNode.property.name;
+        }
+        else {
+            receiver = objName;
+            callee = calleeNode.property.name;
+        }
+    }
+    else if (calleeNode?.type === 'Identifier') {
+        local = true;
+        callee = calleeNode.name;
+    }
+    else {
+        throw new ParseError('destructuring is only allowed for <ns>.<op>(...) or local function calls', line, 'E_STATEMENT');
+    }
+    const positional = parsePositionalArgs(init.arguments ?? [], vctx, line);
+    const summary = buildLineSummary({
+        callee,
+        line,
+        ctx: vctx,
+        positional,
+        namespace,
+        local,
+        receiver,
+        outputs: valueNames,
+        outputKeys: keys,
+        hasAssignment: true,
+    });
+    extractKeepEntries(positional, line, vctx.symbols);
+    return summary;
+}
+/** ExpressionStatement 分类（重赋值 / 本机副作用调用 / 成员方法 / 命名空间裸调用）。 */
+function classifyExpression(expr, line, vctx, lines) {
+    if (expr?.type === 'ImportExpression') {
+        throw new ParseError('dynamic import() is not allowed in faijs (no control flow)', line, 'E_CONTROL_FLOW');
+    }
+    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');
+    }
+    // 裸重赋值 part0 = [await] cad.op(...)
+    if (expr?.type === 'AssignmentExpression' && expr.operator === '=' && expr.left?.type === 'Identifier') {
+        const varName = expr.left.name;
+        if (!vctx.symbols.declared.has(varName)) {
+            if (vctx.looseVars) {
+                vctx.symbols.declared.add(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' && isOpCallCallee(init, vctx)) {
+            const summary = classifyOpCall(init, line, vctx, { output: varName, hasAssignment: true });
+            lines.push(summary);
+            return;
+        }
+        throw new ParseError('re-assignment must be a cad.op() call', line, 'E_STATEMENT');
+    }
+    // 成员方法 / 命名空间裸调用（无赋值）
+    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 isNs = vctx.symbols.nsBindings.has(objName) || objName === vctx.symbols.defaultNsName;
+        const isReceiver = vctx.symbols.declared.has(objName);
+        if (isNs || isReceiver || vctx.looseVars) {
+            const summary = classifyOpCall(expr, line, vctx, { hasAssignment: false });
+            lines.push(summary);
+            return;
+        }
+        throw new ParseError(`unknown variable "${objName}" in .${expr.callee.property.name}() call`, line, 'E_REFERENCE');
+    }
+    // 本机函数副作用调用 myFn(part0, {...})
+    if (expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier') {
+        const fnName = expr.callee.name;
+        if (vctx.symbols.localFnParams.has(fnName) || vctx.looseLocalCalls) {
+            const summary = classifyOpCall(expr, line, vctx, { hasAssignment: false });
+            lines.push(summary);
+            return;
+        }
+        throw new ParseError(`function "${fnName}" does not exist in this script`, line, 'E_REFERENCE');
+    }
+    throw new ParseError(`bare expression statements not allowed; use 'const part0 = cad.op(...)' instead`, line, 'E_STATEMENT');
+}
+//# sourceMappingURL=metadata-extractor.js.map