@faicad/faijs 0.13.0

package/dist/cad-runtime/module-executor.js

@@ -0,0 +1,630 @@
+/**
+ * module-executor — JS VM 模块加载与增量调度（VM 执行方案 Phase 1）
+ *
+ *
+ * ModuleExecutor 是 VM 执行的核心：
+ * - `ctx` 持久变量容器（跨 execute/append/update 存活）
+ * - `load(code)` 用 data:/Blob URL 动态 import 编译产物（零 import，两平台同构）
+ * - `executeAll/executeIds/executeFrom` 按 deps 拓扑序调度
+ * - `reconcileCtx` 回收"定义语句已不在脚本中"的变量并释放其内核资源
+ * - `cache` 记录每语句 statementKey + outputContentKey（plan 增量判定）
+ */
+import { isVarRef, isExprRef, statementInputs } from '../lang/types.js';
+import { withoutKeepDirectives, withoutKeepDirectivesFromPositional } from '../lang/keep.js';
+import { OpError } from '../api/internal/result-unwrap.js';
+import { asPartName } from '../identity.js';
+import { computeContentKey } from './content-key.js';
+import { getSlot, hasBrep, brepOf, ensureSlot, isCompoundLike } from '../shape.js';
+import { setCurrentStmt, setName, getBackends, takePendingAssemblyTransforms, enterFunctionBrep, exitFunctionBrep, takeFunctionBrepDomain } from '../runtime-state.js';
+import { applyTransform } from '../mesh/rigid-transform.js';
+import { applyTransformBrep } from '../brep/brep-ops.js';
+/** 动态 import 编译产物（Node: data: URL；浏览器: Blob URL）。 */
+async function importModule(code) {
+    const isNode = typeof process !== 'undefined' && !!process.versions?.node;
+    if (isNode) {
+        const url = `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`;
+        return import(/* @vite-ignore */ url);
+    }
+    const blob = new Blob([code], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    try {
+        return await import(/* @vite-ignore */ url);
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}
+/**
+ * 收集一个值可到达的全部 BREP 句柄（函数返回值 keep 集，§5.6）：
+ * shape → 身份槽 solid；compound → children 递归；数组 / 普通对象 → 递归。
+ */
+function collectBrepHandles(v, out) {
+    if (v === null || v === undefined)
+        return;
+    if (typeof v !== 'object')
+        return;
+    if (v instanceof Set || v instanceof Map)
+        return;
+    // shape：身份槽持 OCCT 句柄
+    const slot = getSlot(v);
+    if (slot?.solid)
+        out.add(slot.solid);
+    // compound children / 数组 / 对象递归
+    if (Array.isArray(v)) {
+        for (const item of v)
+            collectBrepHandles(item, out);
+        return;
+    }
+    if (isCompoundLike(v)) {
+        for (const child of v.children)
+            collectBrepHandles(child, out);
+        return;
+    }
+    for (const k of Object.keys(v)) {
+        // 跳过内部元数据字段（positions/indices/kind 等 mesh 数据不含句柄，无需遍历）
+        if (k === 'positions' || k === 'indices' || k === 'kind')
+            continue;
+        collectBrepHandles(v[k], out);
+    }
+}
+/**
+ * ModuleExecutor loads JS VM modules and schedules incremental execution.
+ *
+ * It is the heart of the VM execution approach: it keeps the persistent `ctx`
+ * variable container alive across execute/append/update calls, dynamically
+ * imports compiled modules from data:/Blob URLs (zero imports, isomorphic on
+ * both platforms), schedules all/selected/from statements in dependency
+ * topological order, reclaims variables whose defining statements have left the
+ * script, and caches each statement's key + output content key for incremental
+ * planning.
+ */
+export class ModuleExecutor {
+    /** Persistent variable container across incremental executions. */
+    ctx = {};
+    stmts = new Map();
+    /** statementKey 缓存（增量判定；key = op|JSON(args)|deps 的 outputContentKey） */
+    cache = new Map();
+    /**
+     * 函数体 keep 登记（keep-syntax 设计 §2.2）：
+     * stmtId → { kept, hidden }。语句执行前清空本条记录，执行中累加；
+     * 本轮未执行（缓存命中）→ 保留上一轮记录（keep 零重算的前提）。
+     */
+    internalKeep = new Map();
+    sourceById = new Map();
+    metaById = new Map();
+    script = { params: [], statements: [] };
+    lastCode = '';
+    /**
+     * 默认命名空间绑定名（U10/R2）：与 runtime 的 registerLib(…, {default: true}) 声明同步；
+     * statementKey/computeKey 中 namespace 缺省（undefined）的语句按该绑定名计 key。
+     */
+    defaultNsName = 'cad';
+    /**
+     * Sync the default namespace binding name (called by runtime.registerLib with {default:true}).
+     * @param name - the namespace binding name to use as default.
+     */
+    setDefaultNsName(name) {
+        this.defaultNsName = name;
+    }
+    namespaces;
+    /** 库内容身份表（binding → content hash；增量 key 版控，B2 §7.3） */
+    libIds = new Map();
+    /** 本机函数调用嵌套深度（§5.5）：> 0 表示当前在函数体内执行——keep 登记被抑制。 */
+    userFunctionDepth = 0;
+    releaseSolid;
+    getSolid;
+    releaseHandle;
+    setSolid;
+    setFaceEvolution;
+    setRoleTable;
+    constructor(namespaces, options) {
+        this.namespaces = namespaces;
+        this.releaseSolid = options?.releaseSolid;
+        this.getSolid = options?.getSolid;
+        this.releaseHandle = options?.releaseHandle;
+        this.setSolid = options?.setSolid;
+        this.setFaceEvolution = options?.setFaceEvolution;
+        this.setRoleTable = options?.setRoleTable;
+    }
+    /**
+     * Hot-update the assembled namespace set (after registerLib mounts a new
+     * library).
+     * @param namespaces - the new assembled namespaces.
+     * @param libIds - the library content-identity table (binding → libId), used
+     * to version library-branch statement keys (B2, §7.3).
+     */
+    setNamespaces(namespaces, libIds = new Map()) {
+        this.namespaces = namespaces;
+        this.libIds = libIds;
+    }
+    /**
+     * Update the script and its compiled metadata (ctx stays alive).
+     * @param script - the parsed ScriptIR.
+     * @param compiled - the compiled statement metadata.
+     */
+    setCompiled(script, compiled) {
+        this.script = script;
+        this.metaById = new Map(compiled.map((m) => [m.id, m]));
+        this.sourceById = new Map();
+        for (const meta of compiled) {
+            if (meta.sourceIndex !== undefined) {
+                this.sourceById.set(meta.id, script.statements[meta.sourceIndex]);
+            }
+        }
+    }
+    /**
+     * Load the compiled module, skipping a reload when the code is unchanged
+     * (compiled-product cache).
+     * @param code - the compiled module source.
+     */
+    async load(code) {
+        if (code === this.lastCode)
+            return;
+        const mod = await importModule(code);
+        this.stmts = new Map(mod.statements.map((s) => [s.id, s]));
+        this.lastCode = code;
+    }
+    /**
+     * Execute every statement in dependency topological order (i.e. statement
+     * table order).
+     * @param exec - the execution bookkeeping.
+     */
+    async executeAll(exec) {
+        await this.executeIds([...this.stmts.keys()], exec);
+    }
+    /**
+     * Execute only the given statements (append: the prefix is already in the
+     * persistent ctx). As in the old interpreter, beforeStatement fires only for
+     * new_shape statements; void/same_shape statements (do_assemble/add_constraint)
+     * do not trigger it (do_assemble's fn delegates internally).
+     * @param ids - the compiled statement ids to execute.
+     * @param exec - the execution bookkeeping.
+     */
+    async executeIds(ids, exec) {
+        for (const id of ids) {
+            const compiled = this.stmts.get(id);
+            if (!compiled)
+                throw new Error(`[ModuleExecutor] unknown statement "${id}"`);
+            const source = this.sourceById.get(id);
+            const meta = this.metaById.get(id);
+            // 顶替释放预捕获：fn 前捕获本语句写键（{id} ∪ outputs）的旧 handle；
+            // 必须在 fn 之前捕获——op 执行时已用 solidCache.set 覆盖条目，事后拿不到旧引用。
+            const oldHandles = (meta?.writes ?? [])
+                .map((w) => this.getSolid?.(asPartName(w)))
+                .filter((h) => !!h);
+            // P6：changed 由引擎比对推导（替代旧的 touch 声明机制）
+            const oldWrites = new Map();
+            for (const w of meta?.writes ?? [])
+                oldWrites.set(w, this.ctx[w]);
+            setCurrentStmt(source); // P5：新 keep() 归属当前语句
+            // keep 登记先清空本条记录：重执行的语句重新登记（执行中累加，设计 §2.2）
+            this.internalKeep.delete(id);
+            if (source && source.hasAssignment) {
+                exec.beforeStatement?.(String(source.id), this.script.statements.indexOf(source));
+            }
+            // 本机函数调用（local）：进入函数 BREP 域（§5.6），提升 userFunctionDepth（keep 隔离，§5.5）。
+            // 函数体执行期间：内部 keep 登记被抑制（registerKeep no-op）；体内瞬态句柄登记到域，
+            // 结束后释放除返回值可到达句柄外的全部（finally 保证异常路径同样释放）。
+            const isLocal = source?.local === true;
+            if (isLocal) {
+                this.userFunctionDepth++;
+                enterFunctionBrep();
+            }
+            try {
+                await compiled.fn(this.ctx, this.namespaces);
+            }
+            catch (err) {
+                // D4（true-JS-subset §4.3.2）：表达式求值失败（编译产物内标记的
+                // __FaiExprEvalError）包装为 OpError(E_EXPR) 重抛，由 runWithFailureHandling
+                // 归并为 ExecutionResult.failedAt（语句归属经 setCurrentStmt 已定位）。
+                // 其余异常原样抛穿：Brep/MeshUnsupported → failedAt；op 实现的普通异常
+                //（= bug，Result 体系契约）不在此处改变语义。
+                if (err instanceof Error && err.isExprEvalError === true) {
+                    throw new OpError(source?.callee ?? String(id), 'E_EXPR', err.message);
+                }
+                throw err;
+            }
+            finally {
+                if (isLocal) {
+                    this.releaseFunctionBrepDomain(compiled, meta);
+                    exitFunctionBrep();
+                    this.userFunctionDepth--;
+                }
+            }
+            await this.afterStatement(compiled, exec);
+            for (const [w, old] of oldWrites) {
+                if (old !== this.ctx[w])
+                    exec.changed.add(asPartName(w));
+            }
+            // 顶替释放：执行成功后才释放旧 handle（失败时缓存保持执行前状态，天然回滚）
+            for (const old of oldHandles) {
+                this.releaseHandle?.(old);
+            }
+        }
+    }
+    /**
+     * Re-execute from the change points on (update: plan derives the stale set).
+     * The stale set is closed over deps (a statement depending on a stale one is
+     * itself stale) and runs in topological order.
+     * @param staleIds - the set of stale statement ids to recompute.
+     * @param exec - the execution bookkeeping.
+     */
+    async executeFrom(staleIds, exec) {
+        const ordered = [];
+        const visited = new Set();
+        const visit = (id) => {
+            if (visited.has(id))
+                return;
+            visited.add(id);
+            const meta = this.metaById.get(id);
+            if (meta) {
+                for (const dep of meta.deps) {
+                    if (staleIds.has(dep))
+                        visit(dep);
+                }
+            }
+            ordered.push(id);
+        };
+        for (const id of staleIds)
+            visit(id);
+        await this.executeIds(ordered, exec);
+    }
+    /**
+     * Reclaim ctx variables whose defining statement is no longer in the script
+     * and release their kernel resources (a required action after undoing a
+     * statement deletion). Variables in `referencedVars` are kept even when not
+     * written by an active statement (cross-file references to other files'
+     * parts).
+     * @param activeStmtIds - the ids of statements still considered active.
+     * @param writeSets - mapping of statement id to the variable names it writes.
+     * @param referencedVars - variable names still referenced by the active
+     * script; these survive reclaim.
+     */
+    reconcileCtx(activeStmtIds, writeSets, referencedVars) {
+        const activeWrites = new Set();
+        for (const [id, writes] of writeSets) {
+            if (activeStmtIds.has(id)) {
+                for (const w of writes)
+                    activeWrites.add(w);
+            }
+        }
+        for (const key of Object.keys(this.ctx)) {
+            if (!activeWrites.has(key) && !(referencedVars?.has(key) ?? false)) {
+                this.releaseSolid?.(asPartName(key));
+                delete this.ctx[key];
+            }
+        }
+        // keep 登记同步修剪：语句已不在脚本中（undo 删除）→ 其 keep 声明失效
+        for (const id of [...this.internalKeep.keys()]) {
+            if (!activeStmtIds.has(id))
+                this.internalKeep.delete(id);
+        }
+    }
+    // ── 缓存访问（plan / collectResult 用） ──
+    /** 清除所有缓存（key 缓存 + ctx 变量）。测试用：CadRuntime.clearStatementCache 调用。 */
+    clearCache() {
+        for (const key of Object.keys(this.ctx)) {
+            this.releaseSolid?.(asPartName(key));
+            delete this.ctx[key];
+        }
+        this.cache.clear();
+        this.script = { params: [], statements: [] };
+        this.metaById.clear();
+        this.stmts.clear();
+        this.sourceById.clear();
+        this.internalKeep.clear();
+        this.lastCode = '';
+    }
+    /**
+     * Read a statement's statementKey cache entry.
+     * @param id - the compiled statement id.
+     * @returns the cached key and output content key, or undefined.
+     */
+    getCachedKey(id) {
+        return this.cache.get(id);
+    }
+    /**
+     * Read a statement's function-body keep registration (used by the terminal-dag
+     * C1 check); undefined when none exists.
+     * @param id - the compiled statement id.
+     * @returns the internal keep record, or undefined.
+     */
+    getInternalKeep(id) {
+        return this.internalKeep.get(id);
+    }
+    /**
+     * Register a function-body keep entry into ModuleExecutor.internalKeep,
+     * accumulating during execution.
+     * @param id - the compiled statement id.
+     * @param names - the kept variable names.
+     * @param hidden - whether the kept variables are hidden.
+     */
+    registerKeep(id, names, hidden) {
+        // 函数 BREP 域 / keep 隔离（§5.5 / D5）：本机函数体内嵌套 cad.* 的库内部
+        // keep 登记一律抑制——保留语义由调用点 keep 表达，函数体不向顶层传播保留。
+        if (this.userFunctionDepth > 0)
+            return;
+        let rec = this.internalKeep.get(id);
+        if (!rec) {
+            rec = { kept: new Set(), hidden: new Map() };
+            this.internalKeep.set(id, rec);
+        }
+        for (const n of names) {
+            rec.kept.add(n);
+            rec.hidden.set(n, hidden);
+        }
+    }
+    /**
+     * 函数 BREP 域释放（§5.6 / D13）：取走当前域的句柄登记表，收集本语句输出
+     * （返回值）可到达的全部句柄为 keep 集，释放登记域内除 keep 集外的全部句柄。
+     * 函数体内中间体的瞬态句柄在此一次性释放——单次调用内存有界，不逐轮释放。
+     */
+    releaseFunctionBrepDomain(compiled, meta) {
+        const domain = takeFunctionBrepDomain();
+        if (domain.length === 0)
+            return;
+        // keep 集：返回值（语句 writes 的 ctx 值，可能是 shape / compound / 数组 / 对象）可到达的句柄
+        const kept = new Set();
+        for (const w of meta?.writes ?? []) {
+            const v = this.ctx[w];
+            collectBrepHandles(v, kept);
+        }
+        for (const h of domain) {
+            if (kept.has(h))
+                continue;
+            try {
+                this.releaseHandle?.(h);
+            }
+            catch { /* 已释放 */ }
+        }
+    }
+    /**
+     * Read a ctx variable.
+     * @param name - the variable name.
+     * @returns the variable value.
+     */
+    getCtxVar(name) {
+        return this.ctx[name];
+    }
+    /**
+     * Write a ctx variable (used to sync assembly transforms from outputCache
+     * back into ctx).
+     * @param name - the variable name.
+     * @param value - the value to store.
+     */
+    setCtxVar(name, value) {
+        this.ctx[name] = value;
+    }
+    /**
+     * All variable names currently held in the persistent ctx (covers parts
+     * executed by previous execute/append/update calls).
+     * @returns the ctx variable names.
+     */
+    listCtxKeys() {
+        return Object.keys(this.ctx);
+    }
+    /**
+     * Returns the compiled metadata in params + statements order.
+     * @returns the compiled statement metadata array.
+     */
+    getMetas() {
+        return [...this.metaById.values()];
+    }
+    /** 清空 ctx 与 statementKey 缓存（CadRuntime.dispose 用）。 */
+    clear() {
+        for (const key of Object.keys(this.ctx))
+            delete this.ctx[key];
+        this.cache.clear();
+        this.internalKeep.clear();
+        this.stmts.clear();
+        this.lastCode = '';
+    }
+    // ── 内部 ──
+    /** 语句执行后：ctx → outputCache 同步 + 身份槽 → solidCache/faceEvolutionCache 同步 + statementKey 缓存 + 装配传播。 */
+    async afterStatement(compiled, exec) {
+        const source = this.sourceById.get(compiled.id);
+        const meta = this.metaById.get(compiled.id);
+        const writes = meta?.writes ?? [];
+        for (const w of writes) {
+            const v = this.ctx[w];
+            if (v !== undefined) {
+                if (typeof v === 'object' && v !== null) {
+                    setName(v, asPartName(w)); // P3：新 keep() 反查走 runtime-state 映射（P5 删 exec 侧）
+                    // 身份槽 → PartName 键控缓存同步（runtime 的 brepSolids/顶替释放/buildBrepTopology 依赖）
+                    const slot = getSlot(v);
+                    if (slot?.solid)
+                        this.setSolid?.(asPartName(w), slot.solid);
+                    if (slot?.faceEvolution)
+                        this.setFaceEvolution?.(asPartName(w), slot.faceEvolution);
+                    if (slot?.roleTable)
+                        this.setRoleTable?.(asPartName(w), slot.roleTable);
+                }
+                exec.outputCache.set(asPartName(w), v);
+            }
+        }
+        const key = meta ? this.computeKey(meta, source) : '';
+        const outputContentKey = this.computeOutputContentKey(compiled);
+        this.cache.set(compiled.id, { key, outputContentKey });
+        // P4：引擎统一发 part-brep-lost（F1：库不再读 currentStmt / 不再 emit）
+        // 语义：上游在 BREP 链上，但本语句产物不在链上 → BREP 链在此断开
+        this.emitBrepLost(compiled.id, source);
+        // P6：装配传播（求解在库，应用与失效在引擎）
+        await this.applyPendingAssemblyTransforms(exec);
+    }
+    /**
+     * P6：装配传播——取走全部待应用变换，引擎应用到成员（mesh 原地 + BREP 槽 + solidCache），
+     * 记录 changed，并让依赖成员的下游语句失效重算（DAG 重放，替代 exec.dependentsOf 图遍历）。
+     */
+    async applyPendingAssemblyTransforms(exec) {
+        const pending = takePendingAssemblyTransforms();
+        if (pending.length === 0)
+            return;
+        const kernel = getBackends().kernel.brep;
+        for (const { compound, transforms } of pending) {
+            const behavior = getSlot(compound)?.behavior;
+            if (!behavior?.memberNames)
+                continue;
+            const children = compound.children ?? [];
+            const memberNames = behavior.memberNames;
+            for (const t of transforms) {
+                const member = children[t.index];
+                const name = memberNames[t.index];
+                if (!member || typeof member !== 'object')
+                    continue;
+                // mesh 原地变换（保留同一对象引用，ctx 与 compound.children 同步看到变更）
+                Object.assign(member, applyTransform(member, t.quaternion, t.pivot, t.translation, t.rotationMatrix));
+                // BREP 刚体变换（可选）：新 solid 写身份槽 + solidCache（替代旧 T6.5 反同步循环）
+                const solid = brepOf(member);
+                if (kernel && solid) {
+                    const transformed = applyTransformBrep(kernel, solid, t.quaternion, t.pivot, t.translation);
+                    try {
+                        kernel.release(solid);
+                    }
+                    catch { /* 已释放 */ }
+                    ensureSlot(member).solid = transformed;
+                    if (name)
+                        this.setSolid?.(asPartName(name), transformed);
+                }
+                if (name)
+                    exec.changed.add(asPartName(name));
+            }
+            // 下游失效重算：依赖成员名的语句（拓扑序由 executeFrom 按 deps 保证）
+            const stale = this.computeDownstream(memberNames);
+            if (stale.size > 0)
+                await this.executeFrom(stale, exec);
+        }
+    }
+    /** 找出依赖给定变量名的语句（装配成员 → 消费它的下游）。 */
+    computeDownstream(memberNames) {
+        const names = new Set(memberNames);
+        const stale = new Set();
+        for (const [id, source] of this.sourceById) {
+            if (statementInputs(source).some((n) => names.has(String(n))))
+                stale.add(id);
+        }
+        return stale;
+    }
+    /**
+     * 判定并发 part-brep-lost 事件。
+     *
+     * 判据：语句有几何输入且**全部**输入都在 BREP 链上，但输出**不在**链上
+     * → BREP 链在此断开（mesh-only 函数或 fallthrough）。
+     *
+     * true-JS-subset §4.4.2：几何输入 = positional 中的 VarRefIR + ExprIR.refs
+     * （表达式实参引用的 Shape 变量同样喂进本语句；CallRef 嵌套调用是只读查询不计）。
+     */
+    emitBrepLost(id, source) {
+        if (!source)
+            return;
+        const inputNames = new Set();
+        const scanPositional = (arg) => {
+            if (arg === null || typeof arg !== 'object')
+                return;
+            if (isVarRef(arg)) {
+                inputNames.add(String(arg.$ref));
+                return;
+            }
+            if (isExprRef(arg)) {
+                for (const r of arg.$expr.refs)
+                    inputNames.add(r);
+                return;
+            }
+        };
+        for (const arg of source.positional ?? [])
+            scanPositional(arg);
+        if (inputNames.size === 0)
+            return;
+        const sink = getBackends().events;
+        if (!sink)
+            return;
+        const inputsOnChain = [...inputNames]
+            .map((n) => this.ctx[n])
+            .filter((v) => !!v && typeof v === 'object');
+        if (inputsOnChain.length === 0)
+            return;
+        if (!inputsOnChain.every(hasBrep))
+            return; // 上游本就不在链上 → 非断开
+        const out = this.ctx[this.metaById.get(id)?.writes[0] ?? ''];
+        if (out && typeof out === 'object' && hasBrep(out))
+            return; // 输出仍在链上
+        sink.emit('part-brep-lost', {
+            partName: asPartName(String(source.outputs[0] ?? '')),
+            callee: source.callee,
+            reason: `${source.callee} has no BREP implementation`,
+        });
+    }
+    /**
+     * Compute a statementKey = op | JSON(positional + args without keep) | each
+     * dependency's output content key (parameter statements use the parameter
+     * value). The keep/keepHidden keys are excluded so toggling retain/hide state
+     * triggers no geometric recompute. plan() uses this with the current cache to
+     * compute the expected key for incremental decisions.
+     *
+     * true-JS-subset §4.4.1：位置实参槽入 key——ExprIR 可 JSON 化
+     * （text + refs + params），表达式文本变化即触发重算；表达式引用的上游变量
+     * 变化经 deps 的 outputContentKey 传递。
+     *
+     * 本机函数调用（local）：key 前缀 `local.<callee>#<bodyHash>`（§6.2 / P4 内容寻址）——
+     * 编辑函数体文本 → 所有调用该函数的语句 key 变化 → 下游失效重算；不改函数体零重算。
+     * @param meta - the compiled statement metadata.
+     * @param source - the source statement, or undefined for parameter statements.
+     * @returns the computed statement key string.
+     */
+    computeKey(meta, source) {
+        const primary = meta.writes[0];
+        if (!source) {
+            const p = this.script.params.find((pp) => pp.name === primary);
+            return `param|${JSON.stringify(p?.value)}`;
+        }
+        const parts = [
+            source.local
+                ? `local.${source.callee}#${this.bodyHashOf(source.callee)}`
+                : `${source.namespace ?? this.defaultNsName}.${source.callee}#${this.libIdOf(source.namespace ?? this.defaultNsName)}`,
+        ];
+        parts.push(JSON.stringify({
+            positional: withoutKeepDirectivesFromPositional(source.positional ?? []),
+            args: withoutKeepDirectives(source.args),
+        }));
+        for (const dep of meta.deps) {
+            const ck = this.cache.get(dep)?.outputContentKey;
+            parts.push(ck ?? 'missing');
+        }
+        return parts.join('|');
+    }
+    /**
+     * 按函数名查 bodyHash（setCompiled 已存 script；查不到 → 'missing'，增量会失效重算）。
+     * @internal runtime.planUpdateStale 的 ownKey/oldKey 对比（§6.2 / P4）复用。
+     * @param name 本机函数名。
+     * @returns 函数体的内容哈希；`'missing'` 表示未知函数。
+     */
+    bodyHashOf(name) {
+        return this.script.functions?.find((f) => f.name === name)?.bodyHash ?? 'missing';
+    }
+    /**
+     * 按绑定名查 libId（setNamespaces 已存表；本机函数不含——只适用于库分支 key）。
+     * 库未登记或表缺失 → 'missing'，增量会自动失效重算。
+     * @param binding 命名空间绑定名。
+     * @returns 库的内容身份；`'missing'` 表示该绑定无登记身份。
+     */
+    libIdOf(binding) {
+        return this.libIds.get(binding) ?? 'missing';
+    }
+    /** outputContentKey：shape 语句 = mesh 内容哈希；参数语句 = 参数值。 */
+    computeOutputContentKey(compiled) {
+        const primary = this.metaById.get(compiled.id)?.writes[0];
+        if (primary !== undefined) {
+            const v = this.ctx[primary];
+            if (v && typeof v === 'object' && 'positions' in v && 'indices' in v) {
+                const shape = v;
+                return computeContentKey(shape.positions, shape.indices);
+            }
+        }
+        const source = this.sourceById.get(compiled.id);
+        if (!source) {
+            const p = this.script.params.find((pp) => pp.name === primary);
+            return `param:${JSON.stringify(p?.value)}`;
+        }
+        return '';
+    }
+}
+//# sourceMappingURL=module-executor.js.map