@nudojs/core 2.1.0 → 3.0.0-beta.0

package/dist/index.d.ts

@@ -1,6 +1,20 @@
-import { A as Abs, P as Phi, a as AstEnv, C as Confidence, b as Pred, S as Shape, T as Term, c as AbsModuleExports, d as PrimName, R as RelSource, H as HofSite } from './index-DxjxtxOJ.js';
-export { $ as $add, e as $arr, f as $arrMutContainer, g as $arrRest, h as $async, i as $asyncReturn, j as $await, k as $call, l as $callNamed, m as $catchVal, n as $class, o as $concat, p as $div, q as $elems, r as $eq, s as $eqLoose, t as $fnVal, u as $for, v as $forIter, w as $forOf, x as $fork, y as $ge, z as $gen, B as $get, D as $gt, E as $idx, F as $idxSet, G as $invoke, I as $invokeSuper, J as $isForkExit, K as $join, L as $le, M as $len, N as $lit, O as $loopReturn, Q as $lt, U as $mod, V as $mul, W as $ne, X as $neLoose, Y as $neg, Z as $new, _ as $not, a0 as $nullishTest, a1 as $obj, a2 as $objRest, a3 as $optionalGet, a4 as $optionalInvoke, a5 as $orDefault, a6 as $pushLoopExit, a7 as $regex, a8 as $rethrowIfNudoReturn, a9 as $set, aa as $setKey, ab as $spread, ac as $staticInvoke, ad as $sub, ae as $super, af as $switch, ag as $thisGet, ah as $thisSet, ai as $throw, aj as $tryCurrentMark, ak as $tryMark, al as $tryPopMark, am as $tryTakeSince, an as $typeof, ao as $while, ap as $whileSeq, aq as $yield, ar as BCallRecord, as as BClassSpec, at as BMemberDiag, au as DEFAULT_MAX_LOOP_ITERS, av as HofCollectCtx, aw as LiteralValue, ax as NudoReturn, ay as NudoThrow, az as RunTranspiledOptions, aA as TranspileOptions, aB as TranspiledCallResult, aC as abs, aD as absToString, aE as alphaOf, aF as and, aG as anyVar, aH as app, aI as applyCallbackAbs, aJ as asAbs, aK as asAbsVal, aL as betaOf, aM as bindImports, aN as bool, aO as boolLit, aP as callAtFunctionBoundary, aQ as callTranspiledExport, aR as callTranspiledExportFull, aS as clearBClasses, aT as collectAbsExports, aU as confJoin, aV as createHofCollectCtx, aW as currentExecPhi, aX as emptyPhi, aY as eq, aZ as ge, a_ as geNum, a$ as getAbsOrigin, b0 as getBCallCollector, b1 as getBClass, b2 as gt, b3 as gtNum, b4 as implies, b5 as instantiateReturn, b6 as isArrMutator, b7 as isDefinitelyFalse, b8 as isDefinitelyTrue, b9 as isEvalMissingSlotEnabled, ba as isExactLit, bb as isNudoReturn, bc as isNudoThrow, bd as isNumPrim, be as isRelFn, bf as isStrPrim, bg as le, bh as leNum, bi as lit, bj as litTruth, bk as litValue, bl as lt, bm as ltNum, bn as mapElementFallback, bo as namespaceNameOf, bp as ne, bq as never, br as not, bs as noteMemberDispatchMiss, bt as noteObjSlotMissing, bu as notePrimMemberMissing, bv as noteUnknownMemberMissing, bw as num, bx as numLit, by as numVar, bz as obj, bA as or, bB as pFalse, bC as pTrue, bD as phiAnd, bE as predEquals, bF as predToString, bG as predVars, bH as projectFlatMapResult, bI as promoteParamShape, bJ as ptypeof, bK as pushLoopExit, bL as pushThrowExit, bM as recordMemberDiag, bN as registerBClass, bO as runTranspiled, bP as runWithEvalMissingSlot, bQ as runWithLoopExits, bR as setApplyCallbackHost, bS as setBCallCollector, bT as setEvalMissingSlotEnabled, bU as setMemberDiagCollector, bV as shapeOfTerm, bW as shapeToString, bX as simplifyTerm, bY as snapshotAbs, bZ as str, b_ as strLit, b$ as substAbs, c0 as substPred, c1 as substPredAbs, c2 as tagAbsOrigin, c3 as takeLoopExits, c4 as takeThrowExits, c5 as termEquals, c6 as termToString, c7 as transpile, c8 as transpileExpression, c9 as transpileFile, ca as transpileSource, cb as tryPromoteDirectCall, cc as tryPromoteForOfIteratee, cd as tryPromoteHofCallback, ce as tryPromoteReceiverAsArr, cf as undefAbs, cg as unknown, ch as v, ci as withExecPhi } from './index-DxjxtxOJ.js';
-import { Node, File } from '@babel/types';
+import { c as AstEnv, A as Abs, b as Phi, C as Confidence, T as Term, H as HofCollectCtx, S as Shape, a as Pred, R as RelSource, w as HofSite } from './hof-types-oZFaba5a.js';
+export { I as ImplicationOracle, L as LiteralValue, P as PrimName, x as TYPEOF_NAMES, y as TypeofName, z as abs, B as absToString, D as and, F as anyAbs, G as anyVar, J as app, K as bigintLit, N as bool, O as boolLit, Q as confJoin, U as emptyPhi, V as eq, W as ge, X as geNum, Y as getImplicationOracle, Z as gt, _ as gtNum, a0 as implies, a1 as isBigPrim, a2 as isExactLit, a3 as isNumPrim, a4 as isStrPrim, a5 as le, a6 as leNum, a7 as lit, a8 as litValue, a9 as lt, aa as ltNum, ab as ne, ac as negatePred, ad as never, ae as not, af as num, ag as numLit, ah as numVar, ai as obj, aj as or, ak as pFalse, al as pTrue, am as phiAnd, an as predEquals, ao as predToString, ap as predVars, aq as primToTypeof, ar as ptypeof, as as setImplicationOracle, at as shapeOfTerm, au as shapeToString, av as simplifyTerm, aw as str, ax as strLit, ay as substPred, az as termEquals, aA as termToString, aB as unknown, aC as v } from './hof-types-oZFaba5a.js';
+import { Node } from '@babel/types';
+import { p as parseSource, L as LeakBudget, E as EffectiveInterfaceOpts, b as LoadDepsFingerprint, i as CheckReport, N as NudoConstraint } from './check-report-BnOr1M8o.js';
+export { j as CheckAction, C as CheckIssue, k as CheckJson, o as CheckJsonMulti, q as ConstraintBuilder, D as Diagnostic, u as EffectiveInterface, G as GitlabCodeQualityIssue, v as InterfaceDiag, I as InterfaceSource, w as InterfaceTierInfo, a as InterfaceTierOpts, x as NamedImport, y as NudoField, z as NudoFnConstraint, A as NudoSidecarError, B as NudoSig, R as RefineDiag, F as RefineEntry, H as RefineResolveOpts, S as SELF, J as actionsForIssue, K as any, M as array, O as boolean, P as checkArg, Q as checkCall, T as constraintToEntryAbs, U as effectiveInterface, V as execNudoModule, W as extractDeclaredThrows, X as extractNudoImports, Y as extractRefineReturnFromSource, Z as extractRefinesFromSource, _ as fn, $ as fnConstraintToEntryReqs, a0 as formatCheckReport, a1 as formatConstraint, a2 as formatDiagnostics, a3 as formatEffectiveInterfaceDisplay, a4 as formatGithubAnnotations, a5 as formatGitlabCodeQuality, a6 as formatInterfaceTierLine, a7 as generatedExportNames, a8 as getParseSourceCacheSize, a9 as getTerm, aa as instantiateConstraint, ab as interfaceDiagCount, ac as interfaceSourceOf, ad as interfaceTierOf, ae as isIntFlag, af as isNodeModulesPath, ag as isNudoConstraint, ah as lenTerm, ai as localNamedExports, aj as number, ak as omit, al as partial, am as pick, an as refineDiagCount, ao as refineToIndexedFull, ap as resetNudoModuleExecCache, aq as resetParseSourceCache, ar as serializeCheckJson, as as serializeCheckJsonMulti, at as setInterfaceDiagCollector, au as setRefineDiagCollector, av as shape, aw as sidecarClosureFingerprint, ax as sidecarPathOf, ay as string, az as takeInterfaceDiags, aA as takeInterfaceDiagsSince, aB as takeRefineDiags, aC as takeRefineDiagsSince, aD as throwConstraintToKinds, aE as union } from './check-report-BnOr1M8o.js';
+import { A as AbsModuleExports, R as RunTranspiledOptions } from './index-BWgSZGm0.js';
+export { $ as $add, a as $arguments, b as $arr, c as $arrMutContainer, d as $arrRest, e as $arrWithHoles, f as $assignRecord, g as $async, h as $asyncReturn, i as $await, j as $bitand, k as $bitnot, l as $bitor, m as $bitxor, n as $call, o as $callNamed, p as $catchVal, q as $class, r as $classExpr, s as $collectionForEach, t as $concat, u as $copy, v as $del, w as $delRes, x as $div, y as $dynamicImport, z as $elems, B as $eq, C as $eqLoose, D as $fnVal, E as $for, F as $forInKeys, G as $forIter, H as $forOf, I as $fork, J as $ge, K as $gen, L as $get, M as $gt, N as $idx, O as $idxSet, P as $importMeta, Q as $in, S as $instanceof, T as $instanceofNonIdent, U as $invoke, V as $invokeSuper, W as $isBreakTo, X as $isForkExit, Y as $join, Z as $le, _ as $len, a0 as $lit, a1 as $loopBreak, a2 as $loopContinue, a3 as $loopReturn, a4 as $lt, a5 as $mod, a6 as $mul, a7 as $ne, a8 as $neLoose, a9 as $neg, aa as $new, ab as $not, ac as $nullishTest, ad as $obj, ae as $objAccessor, af as $objRest, ag as $optionalGet, ah as $optionalInvoke, ai as $orDefault, aj as $pow, ak as $pushLoopExit, al as $rawThis, am as $reStateCall, an as $recordBinding, ao as $regex, ap as $rethrowIfNudoReturn, aq as $set, ar as $setKey, as as $shl, at as $shr, au as $spread, av as $staticInvoke, aw as $sub, ax as $super, ay as $switch, az as $thisGet, aA as $thisSet, aB as $throw, aC as $toNumber, aD as $tryCurrentMark, aE as $tryDetachSoftCatch, aF as $tryDigestSoftCatch, aG as $tryDiscardSoft, aH as $tryMark, aI as $tryOrphanSoft, aJ as $tryPopMark, aK as $tryReleaseSoftCatch, aL as $tryReleaseSoftOut, aM as $tryTakeSince, aN as $typeof, aO as $unknown, aP as $ushr, aQ as $while, aR as $whileSeq, aS as $yield, aT as BAbsAssignRecord, aU as BCallRecord, aV as BClassSpec, aW as BPathFallback, aX as DEFAULT_MAX_LOOP_ITERS, aY as MAX_B_CALL_DEPTH, aZ as MAX_B_TOTAL_CALLS, a_ as NudoLoopSignal, a$ as NudoReturn, b0 as NudoThrow, b1 as NudoUnsupportedError, b2 as RUNTIME_IMPORT_RE, b3 as TranspileOptions, b4 as TranspiledCallResult, b5 as asAbsVal, b6 as bindImports, b7 as bindingsOf, b8 as callAtFunctionBoundary, b9 as callTranspiledExport, ba as callTranspiledExportFull, bb as clearBClasses, bc as clearStaleTermPred, bd as collectAbsExports, be as currentExecPhi, bf as evalExprAbs, bg as fillTuple, bh as foldRequireSpecArg, bi as foldStaticStringExpr, bj as getBCallCollector, bk as getBClass, bl as isArrMutator, bm as isDefinitelyFalse, bn as isDefinitelyTrue, bo as isNudoBreak, bp as isNudoContinue, bq as isNudoReturn, br as isNudoThrow, bs as litTruth, bt as lookupObjAccessor, bu as namespaceNameOf, bv as noteBCallRecord, bw as noteBPathFallback, bx as pushLoopExit, by as pushThrowExit, bz as registerBClass, bA as resetBCallBudget, bB as runTranspiled, bC as runTranspiledOptionsMemoKey, bD as runWithLoopExits, bE as runtimeImportOf, bF as setBAssignCollector, bG as setBBindingSink, bH as setBCallCollector, bI as setBPathFallbackCollector, bJ as takeLoopExits, bK as takeThrowExits, bL as transpile, bM as transpileBodyNode, bN as transpileExpression, bO as transpileFile, bP as transpileSource, bQ as tryRunTranspiled, bR as withExecPhi } from './index-BWgSZGm0.js';
+
+/**
+ * AstEnv：抽象求值环境类型（ast-eval 删除后保留的类型面）。
+ * 类型定义在 hof-types.ts（打破 ast-env ↔ hof ↔ abs-fn 类型环）；
+ * 本文件保留空环境 / withVar 的便捷构造并重导出 AstEnv 供稳定路径导入。
+ */
+
+/** 空求值环境（分析宿主用：不带任何绑定） */
+declare function emptyEnv(): AstEnv;
+declare function withVar(env: AstEnv, name: string, value: Abs): AstEnv;
 
 type Environment = {
     lookup(name: string): Abs;
@@ -78,13 +92,6 @@ declare function mock(): MockHelper;
  */
 declare function stripTypes<T extends Node>(ast: T): T;
 
-declare function resetParseSourceCache(): void;
-declare function getParseSourceCacheSize(): number;
-declare function parseSource(source: string, opts?: {
-    errorRecovery?: boolean;
-    keepTs?: boolean;
-}): File;
-
 /**
  * 路径约束栈（Φ）。
  *
@@ -116,7 +123,7 @@ type AbsFnImpl = {
     env?: AstEnv;
     kind?: string;
     /** 调用时直接派发（mock withArgs 等），优先于 body */
-    apply?: (args: Abs[]) => Abs;
+    apply?: (args: Abs[], thisVal?: Abs) => Abs;
     /**
      * 对象方法（ObjectMethod / 方法型 FunctionExpression）：$invoke 时把
      * receiver 作为 apply 的**首参**注入。shape.params 仍是用户可见形参
@@ -134,10 +141,27 @@ type AbsFnImpl = {
     relation?: {
         paramTypes: Abs[];
         returnType: Abs;
+        /**
+         * 条件类型 infer：绑定 fromVar 后从 via 投出 inferVar
+         * （`T extends (infer E)[]` → via: "arr"；`T extends Promise<infer U>` → "promise"）。
+         */
+        inferFrom?: {
+            fromVar: string;
+            via: "arr" | "promise";
+            inferVar: string;
+        };
+        /** extends 不成立时的假分支（如 never） */
+        condFallback?: Abs;
     };
+    /** `@nudo:pure`：调用结果按实参记忆化（无副作用契约） */
+    pureName?: string;
 };
 declare function attachFnImpl(a: Abs, impl: AbsFnImpl): void;
 declare function getFnImpl(a: Abs): AbsFnImpl | undefined;
+/** 标记纯函数（@nudo:pure）：调用结果可按实参记忆化 */
+declare function markPureFn(target: object, name: string): void;
+/** 读纯函数标记（Abs impl 或对象属性 `_memoize`） */
+declare function pureFnNameOf(fn: unknown): string | undefined;
 /** 造一个带实现的 Abs 函数值 */
 declare function absFunction(params: string[], impl: Omit<AbsFnImpl, "params">): Abs;
 /** relationFn 稳定 fingerprint（同签名共享，见 §3.3 已知限制） */
@@ -158,6 +182,12 @@ declare function relationFn(paramTypes: Abs[], returnType: Abs, opts?: {
     params?: string[];
     conf?: Confidence;
     fingerprint?: string;
+    inferFrom?: {
+        fromVar: string;
+        via: "arr" | "promise";
+        inferVar: string;
+    };
+    condFallback?: Abs;
 }): Abs;
 /** 仅写 shape 槽（E 路径 / §5.2 提升产物）；禁止 attachFnImpl */
 declare function shapeOnlyFn(paramTypes: Abs[], returnType: Abs, opts?: {
@@ -165,6 +195,147 @@ declare function shapeOnlyFn(paramTypes: Abs[], returnType: Abs, opts?: {
     conf?: Confidence;
 }): Abs;
 
+/**
+ * HOF 关系 Abs：无 body 的外延关系（paramTypes → returnType）的判定、
+ * α 替换与应用。类型变量仍是 term var；关系仍是 fn 形状上的外延槽。
+ */
+
+declare function createHofCollectCtx(paramNames: ReadonlySet<string>, alphaIds: Iterable<string>): HofCollectCtx;
+/**
+ * 仅当 term 是 var 且 id ∈ alphaIds（本次 typeParams）时复用；否则 fresh α。
+ * 绝不把调用点具体值/字面量冻进关系。
+ */
+declare function alphaOf(absOrTerm: Abs | Term | undefined, ctx: HofCollectCtx): Term;
+/** 共享输出变量 B:${param}（§5.1 P2 钉死） */
+declare function betaOf(param: string): Term;
+/**
+ * 提升写入载体：替换 env.vars map 项，禁止 mutate 共享 Abs。
+ * arrival-first：已有 fn/arr 形状 → 拒绝新观测。
+ * 返回是否真正写入。
+ */
+declare function promoteParamShape(env: AstEnv, param: string, promotedShape: Shape, opts?: {
+    loc?: {
+        line: number;
+        column: number;
+    };
+    recordSite?: boolean;
+}): boolean;
+/**
+ * 挂载点①：方法派发 miss。receiver 是形参 Identifier 且 shape 为 any/未知，
+ * 方法名为 filter/map/reduce/flatMap → 提升为 arr(自身 var)。
+ */
+declare function tryPromoteReceiverAsArr(env: AstEnv, receiverName: string, method: string, loc?: {
+    line: number;
+    column: number;
+}): Abs | undefined;
+/**
+ * for-of 迭代对象提升（applyEach 型）：`for (const x of items)`，
+ * items 为形参且仍是 any/unknown → arr(自身 var)。不依赖方法名。
+ */
+declare function tryPromoteForOfIteratee(env: AstEnv, iterateeName: string, loc?: {
+    line: number;
+    column: number;
+}): Abs | undefined;
+/**
+ * 挂载点②：CallExpression callee = 形参 Identifier 直接调用 p(x) / p(a,b)。
+ * 提升为 fn(paramTypes=[αOf(args)], returnType=B:param)。
+ */
+declare function tryPromoteDirectCall(env: AstEnv, calleeName: string, args: Abs[], loc?: {
+    line: number;
+    column: number;
+}): Abs | undefined;
+/**
+ * 挂载点③：HOF 回调实参。回调是 Identifier ∈ paramNames 且尚未有 fn 形状。
+ * 按方法名提升：map/flatMap → fn([αOf(el)], B:param)；filter → fn([αOf(el)], bool)；
+ * reduce → fn([αOf(init), αOf(el)], B:param)。
+ */
+declare function tryPromoteHofCallback(env: AstEnv, cbName: string, method: string, argAbses: Abs[], loc?: {
+    line: number;
+    column: number;
+}): Abs | undefined;
+/** deep-ish copy for snapshot（新对象，不是 env.vars 同一引用） */
+declare function snapshotAbs(a: Abs): Abs;
+/**
+ * 「有可用外延签名」判定：唯一权威定义。
+ *
+ * 名实说明：isRelFn **不要求** term 是 var。完全单态的具体签名
+ * （paramTypes=[number], returnType=string）同样满足——map 有槽就用。
+ * 多态（term=var）只是其中一种形态；名字里的 Rel 指「关系槽可用」。
+ *
+ * 收紧条件——仅有 returnType 而 paramTypes 与 arity 不对齐时，不算 rel，
+ * 防止半截签名在 map 里冒充关系。
+ */
+declare function isRelFn(a: Abs | undefined | null): boolean;
+/**
+ * pred 三条规则：
+ * 1. var ∈ map + 实参有 term → 换 term，可归约则归约，否则残余保留
+ * 2. var ∈ map + 实参无 term → pred → true（conf 由调用方降级）
+ * 3. var ∉ map（自由 α）→ 原样保留
+ */
+declare function substPredAbs(p: Pred, map: ReadonlyMap<string, Abs>): {
+    pred: Pred;
+    dropped: boolean;
+};
+/**
+ * α 替换：map 的 key 是 term var id，value 是替换 Abs。
+ * var ∉ map 原样保留（含自由 α 上的 term/pred）。
+ */
+declare function substAbs(a: Abs, map: ReadonlyMap<string, Abs>): Abs;
+/**
+ * relation-only / isRelFn 的应用：按 paramTypes 做 α 替换得到 returnType。
+ * impl.relation 槽优先于 shape.returnType。重复 α 先绑定保留。
+ * **深度合一**：`T[]` 形参可从 `number[]` 实参绑出 T=number（lodash 泛型）。
+ */
+declare function instantiateReturn(fn: Abs, args: Abs[]): Abs;
+/**
+ * 回调统一入口（单点定义）。A–F + sum：
+ * A Node inline | B apply | C body | D relation | E isRelFn | F unknown
+ *
+ * 实现委托 applyAbsFn（已含 sum / D / E / body 优先）。
+ * Identifier 解析层：env.vars 有 Abs → B–E；env.fns 有 → callFunction；否则 unknown。
+ *
+ * 为避免 hof ↔ exec 循环依赖，本函数由宿主在运行时绑定。
+ *
+ * 依赖说明：宿主在 `exec/call.ts`（B-path `$call` 宿主）加载时注册（副作用）。
+ * 只 import hof.ts 而未加载 exec/call 时，fallback 仅认 relation/isRelFn。
+ * 与 §5.1 的「禁止全局 collector」不同——这里是无状态委托钩子，不是 run 局部状态。
+ */
+type ApplyCallbackHost = (cb: Abs | {
+    type: string;
+}, args: Abs[], env: unknown, phi: unknown, budget: unknown) => Abs;
+/**
+ * B-path 宿主 `exec/call.ts` 加载时注册（副作用）。
+ * 必须经 `exec/call.ts`（或其依赖方：exec/class、generalize）加载，
+ * 才能启用 Identifier/env.fns/inline body 路径；只 import hof.ts 时 fallback
+ * 仅认 relation/isRelFn。勿在多份实例下各写各的——双包/双副本会覆盖。
+ */
+declare function setApplyCallbackHost(fn: ApplyCallbackHost): void;
+/**
+ * 通用回调实参调用（exec/class invokeArrMethod 与 builtins Array.from 共用）：
+ * 原始 JS 函数直调（展开实参）；Abs fn 走 applyCallbackAbs（sum 分发/宿主）。
+ * B 路径 transpile 的箭头回调是 $fnVal Abs——$fnVal.apply 自带调用边界。
+ */
+declare function applyCallbackValue(fn: unknown, args: Abs[], env: unknown, phi: unknown, budget: unknown): Abs;
+declare function applyCallbackAbs(cb: Abs | {
+    type: string;
+}, args: Abs[], env: unknown, phi: unknown, budget: unknown): Abs;
+/** undefined 值的统一 Abs 表示（forEach/find 等） */
+declare function undefAbs(): Abs;
+/**
+ * map 元素投影：body 在符号实参上跑出 unknown 时，
+ * 用 shape.returnType 槽，conf 由调用方按 path/partial 处理。
+ * rel 回调不会走到这里（instantiateReturn 已给出结果）。
+ */
+declare function mapElementFallback(cbAbs: Abs | undefined, elem: Abs, out: Abs): Abs;
+/**
+ * flatMap 统一结果：展开后的元素 join 成 arr(γ)。
+ * JS flatMap 永远返回 Array；双路径共用此投影，禁止一边 tuple 一边 arr。
+ * 同 term 元素 first-wins（joinAbs 会丢 β 身份，见 design §5.1）。
+ */
+declare function projectFlatMapResult(arrConf: Confidence, mapped: Abs[]): Abs;
+/** 从 map/filter/reduce 回调实参里取出 Abs（Identifier 已绑定或直接 Abs） */
+declare function asAbs(v: unknown): Abs | undefined;
+
 /**
  * 算术核：单调性 + 常量折叠 + 约束传播。
  * 这是「类型即计算」的主武器——x>0 时 x+1 必须得到 >1。
@@ -221,6 +392,24 @@ declare function falseConstraint(c: Abs): Pred | undefined;
  * 类型即计算——一元与控制流判定与二元算术同一运算域。
  */
 
+/** & —— ToInt32 两侧后按位与 */
+declare function bitandAbs(a: Abs, b: Abs): Abs;
+/** | —— ToInt32 两侧后按位或 */
+declare function bitorAbs(a: Abs, b: Abs): Abs;
+/** ^ —— ToInt32 两侧后按位异或 */
+declare function bitxorAbs(a: Abs, b: Abs): Abs;
+/** ~ —— ToInt32 后按位取反（bigint 无符号截断） */
+declare function bitnotAbs(a: Abs): Abs;
+/** << —— 左移（rhs ToUint32 & 31；bigint 不限位宽） */
+declare function shlAbs(a: Abs, b: Abs): Abs;
+/** >> —— 算术右移（rhs ToUint32 & 31；bigint 不限位宽） */
+declare function shrAbs(a: Abs, b: Abs): Abs;
+/** >>> —— 逻辑右移（rhs ToUint32 & 31；bigint 无此运算符 → 不可折叠） */
+declare function ushrAbs(a: Abs, b: Abs): Abs;
+/** ** —— 幂（右结合由 AST 保证）；负指数 bigint 原生 RangeError → 不可折叠 */
+declare function powAbs(a: Abs, b: Abs): Abs;
+/** 一元 + —— ToNumber 折叠；bigint 原生恒抛 TypeError → 不可折叠 */
+declare function toNumberAbs(a: Abs): Abs;
 /** JS typeof：结果域永远是 string */
 declare function typeofAbs(a: Abs): Abs;
 /** 一元负号：字面量折叠；符号数翻转不等式 */
@@ -243,81 +432,228 @@ declare function strictEqAbs(a: Abs, b: Abs): boolean | undefined;
 declare function looseEqAbs(a: Abs, b: Abs): boolean | undefined;
 
 /**
- * Abs 侧常用 builtin：shape 级运算，不依赖 TypeValue host 库。
- * 覆盖 Math / Object / JSON / Number / 全局转换函数的常见面。
+ * 对象不变性侧表（freeze/seal/preventExtensions/defineProperty）。
+ * WeakMap 侧表：Abs 不可变，写路径读侧表复现 sloppy 静默失败。
+ */
+
+type ExtState = "nonext" | "sealed" | "frozen";
+type PropFlags = {
+    writable?: boolean;
+    enumerable?: boolean;
+    configurable?: boolean;
+};
+declare function markExtState(o: Abs, s: ExtState): Abs;
+declare function extStateOf(o: Abs): ExtState | undefined;
+declare function getPropFlags(o: Abs): Map<string, PropFlags> | undefined;
+declare function setPropFlags(o: Abs, key: string, f: PropFlags): void;
+/** 写路径产生新副本时迁移不变性侧表（同 migrateAccessors 模式）。
+ *  propFlags 深拷贝：fork/switch 的 $copy 副本不得与源共享可变 Map
+ *  （一臂 defineProperty 不得污染另一臂）。 */
+declare function migrateInvariants(from: Abs, to: Abs): void;
+
+/**
+ * Math.* — 字面量可折叠的返回精确值，否则 number
  */
 
-/** Math.* — 字面量可折叠的返回精确值，否则 number */
 declare function evalMathMethod(name: string, args: Abs[]): Abs | undefined;
-/** Object.keys/values/entries/assign */
+
+/**
+ * Object.assign 非 obj 源键投影 + Object.* 静态方法
+ */
+
+declare function assignSourceSlots(src: Abs): Record<string, {
+    value: Abs;
+}> | undefined;
+/** Object.keys/values/entries/assign + 不变性方法 */
 declare function evalObjectMethod(name: string, args: Abs[]): Abs | undefined;
-/** JSON.parse / stringify */
+
+/**
+ * JSON.parse / JSON.stringify
+ */
+
+/** JSON.parse / stringify：字面量实参真执行折叠；失败硬抛（catch 可吸收） */
 declare function evalJsonMethod(name: string, args: Abs[]): Abs | undefined;
+
+/**
+ * Number.* 静态方法 + parseInt 折叠
+ */
+
 /** Number.isInteger / isNaN / parseFloat 等 */
 declare function evalNumberStatic(name: string, args: Abs[]): Abs | undefined;
-/** 全局 parseInt / parseFloat / isNaN / Number / String / Boolean */
+
+/**
+ * 全局转换函数（parseInt / Number / String / Boolean / Object / Array / Symbol …）
+ */
+
 declare function evalGlobalFn(name: string, args: Abs[]): Abs | undefined;
+
+/**
+ * Array 构造 / Array.* 静态方法
+ */
+
+declare function makeArrayCtorAbs(args: Abs[]): Abs;
 /** Array.isArray / Array.from / Array.of */
 declare function evalArrayStatic(name: string, args: Abs[]): Abs | undefined;
-/** new Date() / Date.now / date.getTime */
+
+/**
+ * Date 构造 / Date.* / Date 实例方法（保守未建模）
+ */
+
 declare function evalDateCtor(args: Abs[]): Abs;
 declare function evalDateStatic(name: string, _args: Abs[]): Abs | undefined;
 declare function evalDateMethod(name: string, _recv: Abs, _args: Abs[]): Abs | undefined;
-/** new RegExp / regexp.test / exec */
-declare function evalRegExpCtor(_args: Abs[]): Abs;
-declare function evalRegExpMethod(name: string, _recv: Abs, _args: Abs[]): Abs | undefined;
-/** Promise：new Promise / Promise.resolve / reject / all */
-declare function evalPromiseCtor(_args: Abs[]): Abs;
+
+/**
+ * RegExp 构造 / brand / 实例方法
+ */
+
+declare function evalRegExpCtor(args: Abs[]): Abs;
+/** RegExp brand：source/flags/lastIndex 进 slots（B-path 与 ast-eval 共用） */
+declare function regexBrandAbsFrom(pattern: string, flags: string): Abs;
+/**
+ * new RegExp(pattern, flags) 字面量真构造验证（$new 与 evalRegExpCtor 共用）：
+ * - 无参 → /(?:)/（原生 source 归一）
+ * - pattern 非字面量（抽象/RegExp 实例）→ undefined（调用方保守）
+ * - symbol pattern / flags → TypeError（ToString 抛）
+ * - 非法 pattern / 非法 flags（含 number/null/boolean flags 的 ToString）
+ *   → SyntaxError；合法 → 精确 brand（source/flags 取真构造结果）
+ */
+declare function tryMakeRegexAbs(args: Abs[]): Abs | undefined;
+declare function evalRegExpMethod(name: string, recv: Abs, args: Abs[]): Abs | undefined;
+
+/**
+ * 内建构造器注册表 + prototype brand / constructor 解析 + Object.prototype 单例 brand
+ */
+
+declare function builtinCtorAbs(name: string): Abs;
+/** Abs 侧内建构造器身份（与宿主构造器名对齐） */
+declare function builtinCtorNameOf(v: unknown): string | undefined;
+/** 宿主全局构造器身份（Number === (42).constructor 折叠用） */
+declare function hostBuiltinCtorName(v: unknown): string | undefined;
+/**
+ * 接收者 → 原型链 constructor 名（`.constructor` 折叠）。
+ * null-proto 无 Object.prototype.constructor → undefined（读侧走 undef）。
+ */
+declare function ctorNameOfRecv(recv: Abs): string | undefined;
+/** `X.prototype` 形态（getPrototypeOf 结果；带 constructor 槽） */
+declare function protoBrandAbs(ctorName: string): Abs;
+/**
+ * Object.getPrototypeOf 的具体原型投影（constructor 链可解）。
+ * null-proto → null 字面量；不可判形态 → unknown（不假装精确原型）。
+ */
+declare function protoOfRecv(a: Abs): Abs;
+declare const OBJECT_PROTO_METHOD_NAMES: Set<string>;
+/** Object.prototype 单例（$get(Object, "prototype") 与 host Object.prototype 共用）。
+ *  带 constructor 槽（不可枚举）供 `.constructor` / `.constructor.name` 链折叠。 */
+declare function objectProtoBrand(): Abs;
+declare function isObjectProtoBrand(a: Abs | undefined): boolean;
+
+/**
+ * Promise 构造 / then 链 / 静态方法 + micro 队列
+ */
+
+declare function enterPromiseExecutorScope(): void;
+declare function leavePromiseExecutorScope(): number;
+/** $fork 在 executor 内发生时打点（多臂 resolve 需 join，不得 first-wins 假精确） */
+declare function notePromiseExecutorFork(): void;
+declare function queuePromiseMicro(task: () => void): void;
+declare function drainPromiseMicros(): void;
+/**
+ * new Promise(executor)：调用 executor(resolve, reject)，收集 resolve 实参作为
+ * promise inner。原生只认第一次 settle——顺序双 resolve 取第一次；执行器内
+ * $fork 分叉时各臂 settle 值 join（路径敏感，不得 first-wins 假精确）。
+ * reject 不填 resolved 通道；永不 settle / 抽象 fn / 执行抛 → promise<unknown>。
+ */
+declare function evalPromiseCtor(args: Abs[]): Abs;
+/** then/catch/finally：可映射回调 → 新 inner；做不到诚实 promise<unknown> */
+declare function evalPromiseMethod(name: string, recv: Abs, args: Abs[]): Abs | undefined;
 declare function evalPromiseStatic(name: string, args: Abs[]): Abs | undefined;
-/** 命名空间分派入口 */
+
+/**
+ * Error 家族 + evalBuiltinNew / evalBuiltinInstanceMethod + namespace 分派
+ */
+
 declare function evalNamespaceCall(ns: string, method: string, args: Abs[]): Abs | undefined;
 declare function isErrorCtorName(name: string | undefined): boolean;
 /**
  * Error brand：shape 带 name/message（字面量 message 保精确）。
+ * AggregateError(errors, message[, options])：message 在第二实参，errors
+ * 挂 .errors（原生是实参数组副本）；options.cause 挂 .cause（闭槽 miss
+ * 会折 undefined 假精确——原生 .cause 可能有值）。
  * $new 与 ast-eval 的 new Error 共用——catch 形参成员访问可解。
  */
-declare function errorBrandAbs(name: string, messageArg?: Abs): Abs;
+declare function errorBrandAbs(name: string, args: Abs[]): Abs;
 /** new X(...) */
 declare function evalBuiltinNew(className: string, args: Abs[]): Abs | undefined;
 /** brand 实例方法（Date/RegExp/Map/Set） */
 declare function evalBuiltinInstanceMethod(brandName: string, method: string, recv: Abs, args: Abs[]): Abs | undefined;
 
 /**
- * Abs 方法表：模板字符串 / 结构值上的方法与属性。
- * 类型即计算——方法结果仍是 Abs，可继续参与约束推理。
- * 宿主 TypeValue 的 dispatchMethod 只服务 IR 兜底，不是真理源。
- * 模板语义（前缀/后缀/固定文本/长度/谓词判定）统一在 template.ts。
+ * String.fromCharCode 等静态方法
  */
 
 /**
- * 调用 Abs 方法。返回 undefined = 未接管（调用方走其它路径）。
+ * String.fromCharCode(...)：
+ * - 全部字面量 → 按 ToUint16 折成精确字符串（含越界/非整数/数字字符串）
+ * - symbol 字面量 → TypeError（ToNumber 抛）
+ * - 任一抽象实参 → 抽象 string（不假精确）
  */
-declare function callAbsMethod(recv: Abs, name: string, args: Abs[]): Abs | undefined;
-/** 属性读取：template/string.length 等 */
-declare function getAbsProperty(recv: Abs, name: string): Abs | undefined;
+declare function evalStringStatic(name: string, args: Abs[]): Abs | undefined;
 
 /**
- * 项（Term）防爆炸：深度/宽度阈值 → leak 为新鲜 var + 等式约束。
+ * Symbol 身份侧表：Symbol() 产生非具体 unique symbol（prim type=symbol，无 term）。
+ * === 按 Abs 引用 / 侧表 id 判定，不把 description 折成可比较字面量身份。
+ * 独立小模块：surface(strictEqAbs) 与 builtins(makeSymbolAbs) 共用，避免环。
  */
 
-type LeakBudget = {
-    maxDepth: number;
-    maxNodes: number;
-};
-declare const defaultLeakBudget: LeakBudget;
-declare function termDepth(t: Term): number;
-declare function termNodes(t: Term): number;
-declare function exceedsBudget(t: Term, budget?: LeakBudget): boolean;
-declare function resetLeakCounter(): void;
+declare function symbolIdOf(a: Abs): number | undefined;
+declare function symbolDescriptionAbs(a: Abs): Abs | undefined;
+declare function isSymbolAbs$1(a: Abs | undefined): boolean;
+
 /**
- * 若项超预算，替换为新鲜变量，并返回附加等式 pred：fresh = originalTerm。
- * 未超预算则原样返回。
+ * Symbol 构造 / 描述 / 字符串化
  */
-declare function maybeLeak(a: Abs, budget?: LeakBudget, label?: string): Abs;
+
+/**
+ * Symbol([description])：非具体 unique symbol（prim type=symbol，无 term）。
+ * - 身份：侧表 id（两个 Symbol() 的 === 为 false；同 Abs 引用为 true）
+ * - .description：字面量 string 或 undefined
+ * - 不折成可比较的字面量身份（description 不作 identity）
+ */
+declare function makeSymbolAbs(descArg?: Abs): Abs;
+declare const isSymbolAbs: typeof isSymbolAbs$1;
+
+/** 全局 Symbol([desc])（$callNamed 身份校验后派发） */
+declare function evalSymbolCtor(args: Abs[]): Abs;
+/** String(sym) → SymbolDescriptiveString（原生不抛；隐式 ToString 才抛） */
+declare function stringOfSymbol(a: Abs): Abs;
+
 /**
- * 批量：在算术结果上应用 leak。
+ * Object.prototype 成员（hasOwnProperty / isPrototypeOf / toString / …）
  */
-declare function leakIfNeeded(a: Abs, budget?: LeakBudget, label?: string): Abs;
+
+/**
+ * Object.prototype 方法语义（B-path $invoke 与 Object.prototype.X.call 共用）。
+ * null-proto 接收者无这些方法——返回 undefined（调用方走 TypeError 路径）。
+ * 返回 undefined = 未接管。
+ */
+declare function evalObjectProtoMethod(name: string, thisVal: Abs, args: Abs[]): Abs | undefined;
+/** Object.prototype.X 一等函数（bindThis：call/apply 把 receiver 注入首参） */
+declare function objectProtoMethodAbs(name: string): Abs;
+
+/**
+ * Abs 方法表：模板字符串 / 结构值上的方法与属性。
+ * 类型即计算——方法结果仍是 Abs，可继续参与约束推理。
+ * 宿主 TypeValue 的 dispatchMethod 只服务 IR 兜底，不是真理源。
+ * 模板语义（前缀/后缀/固定文本/长度/谓词判定）统一在 template.ts。
+ */
+
+/**
+ * 调用 Abs 方法。返回 undefined = 未接管（调用方走其它路径）。
+ */
+declare function callAbsMethod(recv: Abs, name: string, args: Abs[]): Abs | undefined;
+/** 属性读取：template/string.length 等 */
+declare function getAbsProperty(recv: Abs, name: string): Abs | undefined;
 
 /**
  * 结构层：对象槽位、spread、函数重载并。
@@ -329,6 +665,8 @@ type Slot = {
     optional?: boolean;
     readonly?: boolean;
 };
+/** ES 规范数组下标（无前导零、< 2^32-1）；非规范键返回 undefined */
+declare function canonicalArrayIndex(v: unknown): number | undefined;
 type ObjShape = {
     k: "obj";
     slots: Record<string, Slot>;
@@ -389,6 +727,10 @@ declare function fnOf(params: string[], name?: string): Abs;
 declare function joinFunctions(a: Abs, b: Abs): Abs;
 /** 通用 join：分派到对象/函数/值 */
 declare function joinAbs(a: Abs, b: Abs): Abs;
+declare function markNullProtoObj(o: Abs): Abs;
+declare function isNullProtoObj(o: Abs): boolean;
+/** 同一对象的不可变更新（$set/$del）迁移 nullProto 标记 */
+declare function migrateNullProto(from: Abs, to: Abs): Abs;
 
 /**
  * Map / Set 字面量条目追踪（C1.1 / C1.2）。
@@ -413,7 +755,8 @@ type SetTable = {
      */
     maybeAbsent?: true | Set<LitKey>;
 };
-/** $fork 抽象分支：每侧独立 overlay，避免身份表被另一侧 set 污染 */
+/** $fork 抽象分支：每侧独立 overlay，避免身份表被另一侧 set 污染。
+ *  惰性：无集合写入时不分配 WeakMap（fork 热路径上无 Map/Set 是常态）。 */
 type ArmOverlay = WeakMap<object, {
     map?: MapTable;
     set?: SetTable;
@@ -424,12 +767,20 @@ declare function popCollectionArm(): ArmOverlay | undefined;
  * 合并 fork 各臂 overlay → 全局表（由 endCollectionFork 实现）。
  * 保留导出名以免外部测试/调用点漂移。
  */
-declare function mergeCollectionArms(arms: Array<ArmOverlay | undefined>): void;
+declare function mergeCollectionArms(arms: Array<ArmOverlay | undefined | null>): void;
 declare function beginCollectionFork(): void;
 declare function noteCollectionWrite(id: object): void;
-declare function endCollectionFork(arms: Array<ArmOverlay | undefined>): void;
+declare function endCollectionFork(arms: Array<ArmOverlay | undefined | null>): void;
 declare function isMapAbs(a: Abs | undefined): boolean;
 declare function isSetAbs(a: Abs | undefined): boolean;
+/**
+ * 构造器实参**确定**非法（原生 TypeError 域）：
+ * - 非可迭代字面量（number/boolean/symbol/bigint、闭对象字面量）→ Set/Map 都抛
+ * - Map 条目必须是对象：外层 iterable 出现 lit prim 条目（含字符串实参的
+ *   每个字符、tuple/Set 元素）→ TypeError（空串例外：零条目合法）
+ * 抽象形态不确定 → false（保守）。
+ */
+declare function ctorArgDefinitelyInvalid(name: "Map" | "Set", iterable: Abs | undefined): boolean;
 declare function makeMapAbs(iterable?: Abs): Abs;
 declare function makeSetAbs(iterable?: Abs): Abs;
 /** Map#set：fork 内写 overlay；否则原地。返回同一 Abs（JS 可变语义） */
@@ -498,34 +849,12 @@ declare function leqAbs(src: Abs, tgt: Abs, opts?: {
 }): LeqResult;
 
 /**
- * Babel AST 抽象求值：把「类型即计算」接到真实 JS 源码。
- * 支持表达式、函数声明/箭头、return、if、const/let、块作用域、类、循环。
+ * Abs 域记录类型（ast-eval 执行器删除后保留的类型面）。
+ * 运行时记录由 B 通道（BCallRecord/$assignRecord）产生；此处的类型是
+ * checkSource drift / 结构赋值诊断的共享形状。
  */
 
-declare function emptyEnv(): AstEnv;
-declare function withVar(env: AstEnv, name: string, value: Abs): AstEnv;
-type EvalOptions = {
-    phi?: Phi;
-    budget?: LeakBudget;
-    /** 预解析 AST（check 等批量场景避免重复 parse） */
-    file?: File;
-    /** host 已求值的相对依赖导出表 */
-    modules?: Record<string, AbsModuleExports>;
-    /** host 注入（@nudo:mock 等）在求值前绑定（evalSource 也认） */
-    seedVars?: Record<string, Abs>;
-    seedFns?: Record<string, {
-        params: string[];
-        body: Node;
-        async?: boolean;
-    }>;
-};
-declare const MAX_CALL_DEPTH = 64;
-declare const MAX_TOTAL_CALLS = 200000;
-/** 宿主入口（evalProgramAbs / analyzeFn / check）前重置 */
-declare function resetAbsCallBudget(): void;
-/** 记录被截断的递归（service 可映射为 nudo:recursion-truncated） */
-declare function setAbsTruncationCollector(collector: ((fnLabel: string) => void) | null): void;
-/** Abs 域调用记录（自包含程序可不经 TypeValue evaluator） */
+/** Abs 域调用记录（B 通道 BCallRecord 的同形投影） */
 type AbsCallRecord = {
     fnName: string;
     args: Abs[];
@@ -536,10 +865,7 @@ type AbsCallRecord = {
     };
     threw?: boolean;
 };
-/** 设置收集器并返回先前值（嵌套/并发宿主须 restore，勿直接置 null） */
-declare function setAbsCallCollector(collector: ((r: AbsCallRecord) => void) | null): ((r: AbsCallRecord) => void) | null;
-declare function setAbsNodeCollector(collector: ((node: Node, value: Abs) => void) | null): void;
-/** 赋值记录：结构可赋值检查用 */
+/** Abs 域赋值记录（B 通道 $assignRecord 的同形投影） */
 type AbsAssignRecord = {
     name: string;
     prev?: Abs;
@@ -549,130 +875,6 @@ type AbsAssignRecord = {
     /** 分支/循环体内发生：可变绑定在路径上取并集是合法 JS，不参与结构检查 */
     conditional?: boolean;
 };
-declare function setAbsAssignCollector(collector: ((r: AbsAssignRecord) => void) | null): void;
-type EvalResult = {
-    value: Abs;
-    phi: Phi;
-    env: AstEnv;
-    /** 函数已通过 return 跳出，块内后续语句不可达 */
-    returned?: boolean;
-    /** break 跳出最近循环 */
-    brk?: boolean;
-    /** continue 进入下一轮 */
-    cont?: boolean;
-    /** throw 了 value（未捕获时向上传播） */
-    threw?: boolean;
-    /** throw 语句源位置（1-based line，0-based column；Babel loc 口径） */
-    throwLoc?: {
-        line: number;
-        column: number;
-    };
-    /**
-     * if 无 else 且 consequent 已 return/throw：真分支已产出 value，
-     * 假分支 fall-through 仍可能走后续语句。evalBlock 需与后续结果 join。
-     */
-    partialReturn?: boolean;
-    /** 抽象分支可能 throw（另一侧继续）— try 需并 catch 路径 */
-    partialThrow?: boolean;
-    throwValue?: Abs;
-};
-/**
- * 分析一段 JS 源码。
- * 若含多个顶层函数声明，先注册全部，再对 `main` 或最后一个有调用的函数求值。
- * 更简单：提供 `analyzeFunction(source, fnName, args)`。
- */
-declare function evalSource(source: string, entry: {
-    fn: string;
-    args: Abs[];
-}, opts?: EvalOptions): EvalResult;
-/**
- * 调用具名函数并返回 throws/loc（T20）。
- * threw 时 result=never、throws=抛出值、throwLoc=throw 语句位置。
- */
-declare function callFunctionFull(env: AstEnv, name: string, args: Abs[], phi?: Phi, budget?: LeakBudget): {
-    result: Abs;
-    throws: Abs;
-    throwLoc?: {
-        line: number;
-        column: number;
-    };
-};
-declare function callFunction(env: AstEnv, name: string, args: Abs[], phi?: Phi, budget?: LeakBudget): Abs;
-/**
- * 在 this=receiver 下求值方法体。
- * constructor 无显式 return 时返回更新后的 this（字段写入已并入 env）。
- */
-declare function evalMethodBody(method: {
-    params: string[];
-    body: Node;
-    async?: boolean;
-    kind?: string;
-}, args: Abs[], thisVal: Abs, env: AstEnv, phi?: Phi, budget?: LeakBudget, 
-/** 方法定义所在类名（用于 super 派发） */
-ownerClass?: string): Abs;
-/** 对外入口：求值并记入节点表（Map<Node, Abs> 由 collector 消费） */
-declare function evalNode(node: Node, env: AstEnv, phi: Phi, budget: LeakBudget): EvalResult;
-/**
- * 应用 Abs 一等函数。统一顺序：apply → body → relation → isRelFn。
- * 调用门须扩为 `getFnImpl || isRelFn`，否则 E 路径永远进不来。
- */
-declare function applyAbsFn(fnVal: Abs, args: Abs[], env: AstEnv, phi: Phi, budget: LeakBudget): Abs;
-/**
- * 从源码分析指定函数在给定实参下的抽象结果。
- *
- * @example
- * analyzeFn(`
- *   const add = (a, b) => a + b;
- *   function scale(x) { return add(x, 1); }
- * `, "scale", [numVar("x", gtNum(v("x"), 0))], gtNum(v("x"), 0))
- */
-declare function analyzeFn(source: string, fnName: string, args: Abs[], phi?: Phi, budget?: LeakBudget, file?: File, modules?: Record<string, AbsModuleExports>): Abs;
-/**
- * analyzeFn 的 throws/loc 感知版（T19/T20）：threw 时 result=never、throws=抛出值。
- * 供 case 兜底在 B-path 失败时仍可无损拿 throws+loc，不经 TypeValue evaluateFunctionFull。
- */
-declare function analyzeFnFull(source: string, fnName: string, args: Abs[], opts?: EvalOptions): {
-    result: Abs;
-    throws: Abs;
-    throwLoc?: {
-        line: number;
-        column: number;
-    };
-};
-/**
- * 程序级 Abs 求值：注册全部顶层函数/class，再顺序执行语句。
- * 返回最终 env（vars 含导出绑定）。TypeValue 仅在调用方 bridge 时出现。
- *
- * seedVars / seedFns：host 注入（@nudo:mock 等）在求值前绑定。
- * modules：host 已求值的依赖导出表（specifier → AbsModuleExports）。
- */
-declare function evalProgramAbs(source: string, opts?: EvalOptions & {
-    seedVars?: Record<string, Abs>;
-    seedFns?: Record<string, {
-        params: string[];
-        body: Node;
-        async?: boolean;
-    }>;
-    modules?: Record<string, AbsModuleExports>;
-}): {
-    env: AstEnv;
-    last: Abs;
-    phi: Phi;
-};
-/**
- * 收集整文件的节点 → Abs 表（LSP 无损信息源）。
- * 自包含源码上一次 evalProgramAbs 即可；失败返回空表。
- */
-declare function collectAbsNodeTypes(source: string, opts?: EvalOptions & {
-    seedVars?: Record<string, Abs>;
-    seedFns?: Record<string, {
-        params: string[];
-        body: Node;
-        async?: boolean;
-    }>;
-}): Map<Node, Abs>;
-/** 按 loc 找最紧的节点 Abs（hover 用） */
-declare function findAbsAtPosition(nodeTypes: Map<Node, Abs>, line: number, column: number): Abs | undefined;
 
 /**
  * 格式化：把 Abs 渲染成人类可读 / CLI 友好的字符串。
@@ -692,366 +894,9 @@ declare function formatShape(a: Abs): string;
 /** 多行展示，CLI 用 */
 declare function formatAbsMultiline(a: Abs, label?: string): string;
 
-/**
- * 侧车/依赖路径纯函数（leaf 模块：零依赖，供 load-deps-fp / interface /
- * refine / LSP 共享单一定义——历史上三份内联拷贝已各自漂移过）。
- */
-declare function normPath(p: string): string;
-/** core 不引 path：相对 spec 纯字符串拼接（与 LSP resolve 对齐时双方 norm） */
-declare function resolveDepPath(fromFile: string, spec: string): string;
-/**
- * 是否落在 node_modules 下（相对/绝对/盘符形态统一）。
- * autoBind 永不 ambient 加载 node_modules 侧车（§2.2）——必须在 normPath
- * 之后判定，否则 `node_modules/pkg/x.js`（无前导 `/`）会绕过守卫。
- */
-declare function isNodeModulesPath(p: string): boolean;
-/**
- * 源文件的旁路侧车路径：.js/.mjs → 同名 .nudo.js；.ts/.mts → 同名 .nudo.ts。
- * 其他扩展名（.cjs/.jsx/无扩展名…）不做替换，直接追加 .nudo.js——侧车约定
- * 只覆盖四类入口；host loadModule 对不存在的路径返回 miss，自然无侧车来源。
- */
-declare function sidecarPathOf(file: string): string;
-
-/**
- * 约束模板构建器（参数无关）。
- *
- *   number().gt(0)                    → 占位项 self 上的 Pred
- *   number().int().ge(0)              → 整数 + 下界
- *   string().min(1)                   → 非空串（长度）
- *   array(number().gt(0))             → 元素约束
- *   shape({ id: number().gt(0) })     → object 形状约束
- *   lit(42)                           → 字面量（prim + eq(self, 42)）
- *   union(number().gt(0), lit(0))     → 成员析取（or / joinAbs）
- *   fn({ x: number().gt(0) }, number()) → 一等函数约束
- *   number().gt(0).shift(1)           → 界平移（x>0 ⇒ x+n>1）
- *   instantiate("ms")                 → Pred ms > 0 / u.id > 0 ∧ …
- *
- * 在 *.nudo.js 里执行；不是 zod 绑定，是我们自己的运行时 API。
- * 不需要 interface/type 语法——契约用 JS 表达式声明。
- * 注意：本文件的 lit/and 构建器与 term/pred 同名导出在桶导出处冲突，
- * 消费方从 "./constraint.ts" 直接路径导入。
- */
-
-/** 模板占位项；instantiate 时换成真实参数名 */
-declare const SELF = "__nudo_self__";
-/** 字段访问项：u.id */
-declare function getTerm(obj: Term, key: string): Term;
-/** 长度项：length(u) */
-declare function lenTerm(t: Term): Term;
-type NudoField = {
-    constraint: NudoConstraint;
-    optional?: boolean;
-};
-type NudoConstraint = {
-    readonly __nudoConstraint: true;
-    readonly prim?: PrimName;
-    readonly preds: Pred[];
-    /** object 形状：字段名 → 嵌套约束 */
-    readonly fields?: Record<string, NudoField>;
-    /** array 元素约束 */
-    readonly element?: NudoConstraint;
-    /** 整数（number 链式 .int()） */
-    readonly int?: boolean;
-    /** 该约束整体可选（shape 字段用；不用 optional 以免与链式方法撞名） */
-    readonly isOptional?: boolean;
-    /** union 成员（析取）：instantiate 为 or(...)，entry Abs 为成员 join */
-    readonly members?: NudoConstraint[];
-    /** 一等函数约束（fn() 构建器产出） */
-    readonly fn?: NudoFnConstraint;
-};
-/** fn(params, returns?, { throws? }) 的一等函数约束形态 */
-type NudoFnConstraint = {
-    params: Record<string, NudoConstraint>;
-    returns?: NudoConstraint;
-    throws?: NudoConstraint;
-};
-declare function isNudoConstraint(x: unknown): x is NudoConstraint;
-/** 链式约束：不可变，每次 .gt() 返回新对象 */
-type ConstraintBuilder = NudoConstraint & {
-    gt(n: number): ConstraintBuilder;
-    ge(n: number): ConstraintBuilder;
-    lt(n: number): ConstraintBuilder;
-    le(n: number): ConstraintBuilder;
-    /** number：要求整数 */
-    int(): ConstraintBuilder;
-    /** string：长度下界 */
-    min(n: number): ConstraintBuilder;
-    /** string：长度上界 */
-    max(n: number): ConstraintBuilder;
-    /** string：精确长度 */
-    length(n: number): ConstraintBuilder;
-    /**
-     * 界平移：term 平移 n 后重写常数界（x>0 ⇒ x+n>n）。
-     * 仅数值标量界链合法；length 界 / shape / array / union / fn → throw。
-     */
-    shift(n: number): ConstraintBuilder;
-    /** 字段可选（仅在 shape 内有意义） */
-    optional(): ConstraintBuilder;
-};
-/**
- * builder 与纯数据形态统一的 int 标志读取：纯数据看 `int === true`，
- * builder（int 是链式方法）查 WeakSet。toPlainConstraint 归一化后只剩前者。
- */
-declare function isIntFlag(c: NudoConstraint): boolean;
-/** number() —— 约束 number 原语 + 后续链式界 */
-declare function number(): ConstraintBuilder;
-declare function string(): ConstraintBuilder;
-declare function boolean(): ConstraintBuilder;
-/** any() —— 无约束；formatConstraint / draft import 与显示同源 */
-declare function any(): ConstraintBuilder;
-/** array(item) —— 数组，元素满足 item；item 亦可为具体字面量（指令文法） */
-declare function array(item: NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined): ConstraintBuilder;
-/**
- * object 形状约束（契约规范形状，无需 interface）：
- *
- *   shape({ id: number().gt(0), name: string() })
- *
- * 字段值亦可为具体字面量（指令文法）。
- */
-declare function shape(fields: Record<string, NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined>): ConstraintBuilder;
-/** union(...cs)：成员析取；instantiate 为 or(...)，entry Abs 为成员 joinAbs。空参 throw */
-declare function union(...cs: (NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined)[]): ConstraintBuilder;
-/**
- * fn(params, returns?, { throws? })：一等函数约束。
- * Phase 1 只展示不执法：参数位 instantiate 恒真（pTrue），
- * 逐参约束经 fnConstraintToEntryReqs 消费。
- */
-declare function fn(params: Record<string, NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined>, returns?: NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined, opts?: {
-    throws?: NudoConstraint | ConstraintBuilder | number | string | boolean | null | undefined;
-}): ConstraintBuilder;
-/** partial(c)：shape 全字段变可选；非 shape throw */
-declare function partial(c: NudoConstraint | ConstraintBuilder): ConstraintBuilder;
-/** pick(c, keys)：shape 子形状（不存在的 key 忽略）；非 shape throw */
-declare function pick(c: NudoConstraint | ConstraintBuilder, keys: string[]): ConstraintBuilder;
-/** omit(c, keys)：shape 去字段；非 shape throw */
-declare function omit(c: NudoConstraint | ConstraintBuilder, keys: string[]): ConstraintBuilder;
-/** 把模板绑定到参数名：self → paramName；shape 展开为字段访问 Pred */
-declare function instantiateConstraint(c: NudoConstraint, paramName: string): Pred;
-/**
- * 契约 → 函数入口 param Abs（infer/hover 用）。
- * 标量：prim + pred；shape：obj slots 递归；union：成员 joinAbs；
- * fn 形态：退化 unknown（不是参数位标量值），逐参约束由 fnConstraintToEntryReqs 消费。
- */
-declare function constraintToEntryAbs(c: NudoConstraint, paramName: string): Abs;
-/**
- * fn 约束 → 逐参约束表（interface 推导 / 入口签名消费）。
- * 非 fn() 形态 throw——调用方应先判 c.fn。
- */
-declare function fnConstraintToEntryReqs(c: NudoConstraint): Array<{
-    param: string;
-    constraint: NudoConstraint;
-}>;
-
-/**
- * 精化契约解析：唯一形态
- *
- *   @nudo:refine <param> <constraint>    参数精化（挂入口 Abs，参与运算）
- *   @nudo:refine return <constraint>     返回精化（推断返回值 ⊭ 时红）
- *
- * 不叫 requires：那只是「校验挡板」。
- * refine 表示约束是类型的一部分——Abs = shape × term × **pred** × conf，
- * pred 会流入代数（x>0 ⇒ x+1>1），不只是调用点挡一下。
- *
- * constraint 来自 *.nudo.js 导出的模板（number().gt(0) 等），
- * 由 /// @nudo:import { delay } from "./delay.nudo.js" 引入。
- * 不支持写 `x > 0`（绑死参数名）。
- * 不用 JSDoc @param/@return：那是类型注解语法。
- *
- * `@nudo:interface` 是 `@nudo:refine` 的等价别名（渐进迁移，§design-refine-derivation）。
- * 侧车加载：Babel 语句级改写（多行 import / 注释与字符串里的同形文本不误伤）、
- * 相对 .nudo.js/.nudo.ts 经 loadModule 递归求值、环检测、执行失败改诊断
- * （nudo:interface-load / nudo:interface-cycle，不再静默吞错）。
- */
-
-/** `/// @nudo:import { delay, percent } from "./delay.nudo.js"` */
-type NamedImport = {
-    names: string[];
-    spec: string;
-};
-declare function extractNudoImports(source: string): NamedImport[];
-/** refine 侧车加载诊断（severity 由消费方按 code 定档，形状对齐 Issue 子集） */
-type RefineDiag = {
-    code: string;
-    message: string;
-    file?: string;
-};
-/** 设置诊断观察者（null 清除）；缓冲照常累积，takeRefineDiags 取走 */
-declare function setRefineDiagCollector(fn: ((d: RefineDiag) => void) | null): void;
-/** 当前诊断累计序号（since 锚） */
-declare function refineDiagCount(): number;
-/** 取走已收集的诊断（收集即清空） */
-declare function takeRefineDiags(): RefineDiag[];
-/** 只取走 seq > since 的增量（工具面防窃取在途诊断；全量 take 的 since 版） */
-declare function takeRefineDiagsSince(since: number): RefineDiag[];
-/** 侧车模块错误：code ∈ nudo:interface-cycle | nudo:interface-load */
-declare class NudoSidecarError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
-/**
- * 执行 *.nudo.js（真实 JS + 我们的构建器）。import/export 由 Babel 语句级
- * 改写：多行 named import、注释/字符串里的同形文本不误伤；相对 .nudo 递归
- * 求值；环 → throw NudoSidecarError。结果进 exec 缓存（依赖闭包内容指纹键）。
- */
-declare function execNudoModule(src: string, opts?: RefineResolveOpts): Record<string, unknown>;
-type RefineResolveOpts = {
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    /** 侧车自身的路径（相对 spec 解析基准 + 环检测链起点） */
-    fromFile?: string;
-};
-declare function resetNudoModuleExecCache(): void;
-/**
- * 解析 `ms delay` / `n percent` → [param, Pred]
- * 多条用 && 或换行连接。
- * 同时保留原始 NudoConstraint（shape 字段检查用）。
- */
-type RefineEntry = {
-    param: string;
-    pred: Pred;
-    constraint: NudoConstraint;
-};
-declare function extractRefinesFromSource(source: string, fnName: string, opts?: RefineResolveOpts): RefineEntry[];
-/** refine 参数 → 带约束模板的下标表（shape 检查用） */
-declare function refineToIndexedFull(source: string, fnName: string, paramNames: string[], opts?: RefineResolveOpts): Array<[number, RefineEntry]>;
-/**
- * 解析 `@nudo:refine return positive` → 返回精化。
- * 返回 undefined = 无声明（不猜后置）。
- */
-declare function extractRefineReturnFromSource(source: string, fnName: string, opts?: RefineResolveOpts): {
-    name: string;
-    constraint: NudoConstraint;
-} | undefined;
-
-/**
- * Interface 分层推导（design-refine-derivation §2.1/§2.2/§11 第 0 步）：
- *
- *   effectiveInterface(source, fnName) —— 手写 ∪ 侧车同名绑定 ∪ 生成段的
- *   唯一读取口，来源标注（handwritten / generated / implicit）随值返回。
- *
- * 来源三层（合并序 handwritten > generated > implicit，§4/§11）：
- * - handwritten：源码 `@nudo:refine`/`@nudo:interface` 行（复用 refine.ts 的
- *   extractRefinesFromSource / extractRefineReturnFromSource）∪ 侧车同名**手写**
- *   fn() 绑定。同名同参取合取 and()（§2.1：侧车 x>0 + 源码 x>1 → 有效契约
- *   取合取）；常数界交叉矛盾（x>0 ∧ x<0）→ conflict 标记，由调用方报
- *   nudo:interface-conflict——本函数不 throw。
- * - generated：侧车同名导出且声明上方注释块含 @generated 标记（emit 产物）。
- *   与手写并存时整体降级忽略（手写为准；混排由 nudo:interface-name-clash /
- *   drift 在 emit/check 侧处理）。
- * - implicit：无任何契约 → 返回 undefined（隐式推断是调用方的事）。
- *
- * 自动绑定边界（§2.2）：只绑源文件**本地 named export**（re-export /
- * export default / 私有名不绑）；opts.autoBind === false 或侧车路径含
- * /node_modules/ → 不 ambient 加载（只看源码 refine）。「项目根内」检查属
- * 宿主层（core 无 projectDir 概念），Phase 1 不在此实现。
- *
- * 侧车绑定 Phase 1 只承诺 fn() 形态：非 fn 的标量/shape 绑定不消费，收集
- * nudo:interface-load 诊断（后续 Phase 再放开单参形态）。
- *
- * 诊断走本文件独立 side-channel（先例 refine.ts 的 setRefineDiagCollector）：
- * 侧车加载/执行失败 → nudo:interface-cycle / nudo:interface-load。
- */
-
-/** interface 推导诊断（severity 由消费方按 code 定档，形状对齐 Issue 子集） */
-type InterfaceDiag = {
-    code: string;
-    message: string;
-    file?: string;
-};
-/** 设置诊断观察者（null 清除）；缓冲照常累积，takeInterfaceDiags 取走 */
-declare function setInterfaceDiagCollector(fn: ((d: InterfaceDiag) => void) | null): void;
-/** 当前诊断累计序号（since 锚：工具面只排干自身探测产生的增量） */
-declare function interfaceDiagCount(): number;
-/** 取走已收集的诊断（收集即清空） */
-declare function takeInterfaceDiags(): InterfaceDiag[];
-/**
- * 只取走 seq > since 的诊断（清空仅限增量）——LSP 长驻进程里 lens/打印/
- * emit 工具用它排干**自身探测**产生的诊断，不窃取在途 validateText 待消费
- * 的接口诊断（全量 take 曾在 await 窗口偷走 checkSource 的待收诊断）。
- */
-declare function takeInterfaceDiagsSince(since: number): InterfaceDiag[];
-/** 有效契约来源：手写（源码 refine ∪ 侧车手写绑定）> 生成段 > 隐式 */
-type InterfaceSource = "handwritten" | "generated" | "implicit";
-/**
- * 源文件本地导出名表（侧车自动绑定边界）：
- * - ESM：`export function/const/let/var/class` 与本地 `export { x }` /
- *   `export { local as exported }`（按**导出名**绑定）；
- * - `export default function add` / `const add = …; export default add`：
- *   按**本地名** `add` 绑定（侧车可 `export const add = fn(…)`）；
- *   同时登记 `"default"`，供侧车 `export default fn(…)` 对齐；
- * - CJS（C4.3）：`module.exports = { a, b }`、`module.exports.a = …`、
- *   `exports.a = …`、`module.exports = localFn`（登记 localFn 名）。
- * 排除 re-export（`export {x} from` / `export *`）。
- */
-declare function localNamedExports(source: string): Set<string>;
-/**
- * 侧车源码的生成段导出名：export 之前（跳过紧邻的 import/const 链）的注释
- * 行含 `@generated` → 该名为 generated。组合式下行段（§5.3）形态为
- * `import` + `@generated 头` + prelude + export；callsite 段则是头紧贴
- * export。隔了其他代码行 / 无标记 / re-export 列表均不算。
- */
-declare function generatedExportNames(sidecarSrc: string): Set<string>;
-type EffectiveInterfaceOpts = RefineResolveOpts & {
-    /** false（或谓词返回 false）→ 不 ambient 加载侧车；默认 true */
-    autoBind?: boolean | ((sidecarPath: string) => boolean);
-};
-type EffectiveInterface = {
-    fnName: string;
-    params: Array<{
-        param: string;
-        constraint: NudoConstraint;
-    }>;
-    returns?: {
-        constraint: NudoConstraint;
-    };
-    source: InterfaceSource;
-    /**
-     * 合取不可满足标记：params = 常数界交叉矛盾（或 prim 矛盾等 and() 不可
-     * 合取形态）的参数名；returns = 返回位同样不可满足。调用方报
-     * nudo:interface-conflict 并跳过对应位执法。
-     */
-    conflict?: {
-        params: string[];
-        returns?: boolean;
-    };
-};
-/**
- * 单点读取口：手写 ∪ 侧车同名 ∪ 生成段 → 有效契约（含来源标注）。
- * 无任何契约 → undefined（implicit 由调用方处理）。
- */
-declare function effectiveInterface(source: string, fnName: string, opts?: EffectiveInterfaceOpts): EffectiveInterface | undefined;
-/**
- * 侧车及递归 .nudo 依赖闭包的内容指纹：`${hashSource(侧车)}|路径=hash,…`。
- * 无 loadModule / autoBind 关闭 / node_modules / loadModule miss → undefined
- * （无侧车影响即无需指纹）。闭包截断 → `trunc:` 前缀，键不可信，调用方
- * fail-open（参照 loadModuleDepsFingerprint 的 truncated 契约）。
- */
-declare function sidecarClosureFingerprint(fromFile: string, opts: EffectiveInterfaceOpts): string | undefined;
-/** 组合式显示：重建构建器调用形态（number().gt(0) / union(…) / fn(…)） */
-declare function formatConstraint(c: NudoConstraint): string;
-/** EffectiveInterface → 契约展示串（与 CLI interface 打印同口径，不含函数名） */
-declare function formatEffectiveInterfaceDisplay(eff: EffectiveInterface): string;
-/** CodeLens / hover 首行标题（design-refine-derivation §8）：`● interface / <source>` */
-declare function formatInterfaceTierLine(source: InterfaceSource): string;
-type InterfaceTierInfo = {
-    source: InterfaceSource;
-    /** handwritten/generated 时的契约展示；implicit 为 undefined */
-    display?: string;
-};
-type InterfaceTierOpts = EffectiveInterfaceOpts;
-/**
- * interface 档单一读取口（A7）：CodeLens `● interface`、hover、inlay、
- * semantic tokens 共用本函数，保证「同源」。
- *
- * 与 computeInterfaceLenses 同口径：仅源文件 **本地 named export** 进档；
- * 私有名 / 非导出 → undefined（不进 interface 档，不假装 implicit 契约）。
- */
-declare function interfaceTierOf(source: string, fnName: string, fromFile: string, opts?: InterfaceTierOpts): InterfaceTierInfo | undefined;
-/** interfaceTierOf 的来源投影；非导出 → undefined */
-declare function interfaceSourceOf(source: string, fnName: string, fromFile: string, opts?: InterfaceTierOpts): InterfaceSource | undefined;
-
 /**
  * C4.1：函数形参表面（contract surface）——
- * 侧车 `fn({…})` / `@nudo:refine` 参数名与求值形参的对齐基线。
+ * 侧车 `fn({…})` / `@nudo:contract` 参数名与求值形参的对齐基线。
  *
  * - Identifier / 默认参（AssignmentPattern left）→ 绑定名
  * - RestElement → 契约名用裸名（`args`），展示名 `...args`
@@ -1119,48 +964,6 @@ declare function locateContractParam(formals: FormalParam[], contractName: strin
     rest?: boolean;
 } | undefined;
 
-type LoadDepsFingerprint = {
-    fp: string;
-    paths: string[];
-    /**
-     * path + loadModule-resolved content（miss → null）。调用方（磁盘缓存键）
-     * 必须优先用这里的 content，不得回读磁盘——否则 buffer-aware loadModule
-     * 与磁盘不一致时键会分叉。
-     */
-    contents: Array<{
-        path: string;
-        content: string | null;
-    }>;
-    /** BFS 撞到节点上限：剩余 dep 未进指纹，键不可信 */
-    truncated: boolean;
-};
-/**
- * All string module specs that analysis may resolve through loadModule.
- * Regex over-approximates (may hit comments) — extra dep fingerprint is safe
- * (more misses, never a stale hit).
- */
-declare function extractAllLoadSpecs(source: string): string[];
-/**
- * 源里指向其他侧车的相对 spec（`.nudo.js`/`.nudo.ts`）。regex 过近似安全：
- * 多算的 dep 只带来额外 miss，绝不产生陈旧命中。LSP 隐式依赖登记共用。
- */
-declare function sidecarSpecsOf(source: string): string[];
-/**
- * Fingerprint every loadModule-reachable dep (not only `*.nudo.js`), including
- * one hop of transitive specs from each dep source — plus the autoBind 侧车
- * 闭包（`sidecar:` 前缀条目）。
- *
- * 侧车吸收范围 = fromFile 自身 **与每一个成功加载的依赖文件**的旁路侧车及其
- * 递归 .nudo 依赖：跨文件被调（scan.ts checkExternalCall）会按定义文件路径
- * ambient 绑定其侧车，依赖侧车内容影响调用方报告——不进指纹则编辑后 memo
- * 陈旧命中（错诊断）。侧车 loadModule miss（无侧车文件）→ 不加任何条目。
- *
- * 注意：本扩展对 autoBind=false 与 /node_modules/ 均**不** gate（刻意过近似，
- * 只过度失效、绝不陈旧命中——安全方向）；ambient 生效边界由
- * interface.ts 的 sidecarClosureFingerprint 负责，两者职责不同。
- */
-declare function loadModuleDepsFingerprint(source: string, loadModule: (spec: string, fromFile: string) => string | undefined, fromFile: string): LoadDepsFingerprint;
-
 declare function resetGeneralizeMemo(): void;
 declare function getGeneralizeMemoSize(): number;
 /**
@@ -1181,7 +984,7 @@ type PolyFn = {
     instantiate: (args: Abs[], phi?: Phi) => Abs;
     symbolic: Abs;
     display: string;
-    /** 入口契约（@nudo:refine），供签名/inlay 展示 */
+    /** 入口契约（@nudo:contract），供签名/inlay 展示 */
     entryReqs?: Array<{
         param: string;
         pred: Pred;
@@ -1218,7 +1021,7 @@ declare function extractFn(source: string, fnName: string, fileAst?: ReturnType<
 declare function generalizeFromAst(fnName: string, source: string, opts?: {
     budget?: LeakBudget;
     label?: string;
-    /** 传入则把 @nudo:refine 挂到入口 param Abs */
+    /** 传入则把 @nudo:contract 挂到入口 param Abs */
     refine?: EffectiveInterfaceOpts;
     /** 预解析 AST，避免 check 批量场景重复 parse */
     file?: ReturnType<typeof parseSource>;
@@ -1226,303 +1029,49 @@ declare function generalizeFromAst(fnName: string, source: string, opts?: {
     depsFp?: LoadDepsFingerprint;
     /** 预计算 ambient 侧车闭包指纹（checkSource 整文件一次） */
     sidecarFp?: string;
+    /** 宿主已求值的依赖导出表（specifier → AbsModuleExports） */
+    modules?: Record<string, AbsModuleExports | Record<string, unknown>>;
+    /** B run 注入包（modules/mocks/envGlobals/replacements/as）——透传
+     *  runTranspiled；对象身份进 memo 键（调用方同文件内复用同一对象） */
+    inject?: RunTranspiledOptions;
 }): PolyFn | undefined;
 declare function generalizeAll(source: string, opts?: {
     budget?: LeakBudget;
 }): PolyFn[];
-/** 列出源码中的顶层函数名 */
-declare function listFunctionNames(source: string): string[];
-/**
- * 按 assume 集合构造实参：被 assume 的参数给带约束的符号，其余 unknown。
- */
-declare function buildArgsFromAssume(source: string, fnName: string, assumeIds: Set<string>): Abs[];
-
-/**
- * 约束诊断：检查调用点实参是否满足函数的前置约束 / 参数 shape。
- * 输出可行动的建议，而不是 TS 式「类型不匹配」。
- */
-
-type Diagnostic = {
-    severity: "error" | "warning" | "info";
-    code: string;
-    message: string;
-    suggestion?: string;
-    fn?: string;
-    argIndex?: number;
-};
-/**
- * 检查实参是否满足「期望约束」。
- * expect: 相对参数 term 的 pred，例如 term > 0
- * arg: 实际实参 Abs
- */
-declare function checkArg(arg: Abs, expect: Pred | undefined, phi?: Phi): Diagnostic | undefined;
-/**
- * 对一次函数调用做诊断：实参 shape + 约束。
- */
-declare function checkCall(source: string, fnName: string, args: Abs[], phi?: Phi): Diagnostic[];
-declare function formatDiagnostics(diags: Diagnostic[]): string;
-
 /**
- * Template string 拼接（代数侧）。
- * 表示：prim(string) + refinement.meta.templateParts = Abs[]
- * 与 core 的 createTemplate 对齐，使 `"x" + string + "!"` 得到 template refined。
- *
- * 本模块是模板语义的唯一真理源：前缀/后缀/固定文本/长度/匹配/名称渲染/
- * 相邻合并/谓词判定等纯计算以「中性 part 视图」（TemplatePartView）暴露；
- * Abs 方法表（methods.ts）只做薄适配。
+ * 列出源码中的顶层函数名。
+ * 与 scan.listTopFunctions 对齐：解 export default / export const 箭头与函数表达式。
+ * （不 import scan：scan 依赖本文件，避免环。完整 CJS/class 面用 listTopFunctions。）
  */
-
-type TemplateMeta = {
-    templateParts: Abs[];
-};
-/** 单个 part 的分类：固定文本，或抽象 part（携带展示文本） */
-type TemplatePartDesc = {
-    fixed: string;
-} | {
-    render: string;
-};
-/** 带原始 part 回引的视图：既喂语义计算，也用于重建合并结果 */
-type TemplatePartView<P = unknown> = {
-    /** 固定文本；undefined = 抽象 part */
-    fixed: string | undefined;
-    /** 抽象 part 的展示文本（渲染 `${...}` 名时使用） */
-    render: string;
-    part: P;
-};
-declare function viewTemplateParts<P>(parts: P[], describe: (p: P) => TemplatePartDesc): TemplatePartView<P>[];
-/** 前导固定文本（遇到首个抽象 part 停止） */
-declare function knownPrefixOfViews(views: TemplatePartView[]): string;
-/** 尾部固定文本（从末尾遇到首个抽象 part 停止） */
-declare function knownSuffixOfViews(views: TemplatePartView[]): string;
-/** 全部固定文本按序拼接（跨抽象 part） */
-declare function allFixedTextOfViews(views: TemplatePartView[]): string;
-/** 全部 part 均为固定文本时的精确总长；含抽象 part 则 undefined */
-declare function fixedLengthOfViews(views: TemplatePartView[]): number | undefined;
-/** 渲染 `` `lit${render}` `` 形态的模板名 */
-declare function formatTemplateNameViews(views: TemplatePartView[]): string;
-/** 相邻固定文本合并；rebuildFixed 以合并文本重建视图（含原始 part） */
-declare function mergeAdjacentFixedViews<P>(views: TemplatePartView<P>[], rebuildFixed: (text: string) => TemplatePartView<P>): TemplatePartView<P>[];
-/** 具体字符串是否匹配模板（Refinement.check 的判定语义） */
-declare function templateMatchesValue(value: string, views: TemplatePartView[]): boolean;
-/** 三值判定；Abs 方法表把 "unknown" 适配为 boolPrim */
-type TemplatePredicateDecision = boolean | "unknown";
-declare function decideStartsWith(prefix: string, search: string): TemplatePredicateDecision;
-declare function decideEndsWith(suffix: string, search: string): TemplatePredicateDecision;
-declare function decideIncludes(fixedText: string, search: string): TemplatePredicateDecision;
-declare function absTemplateViews(parts: Abs[]): TemplatePartView<Abs>[];
-/** 从 Abs 提取 template parts（已是 template 则展开，否则 [self]） */
-declare function templatePartsOf(a: Abs): Abs[];
-/**
- * 构造 template Abs。
- * - 全字面量 → exact lit
- * - 单 string prim → prim
- * - 否则 prim(string) + pred(name=template, meta.templateParts)
- */
-declare function createTemplateAbs(parts: Abs[]): Abs;
-declare function isTemplateLike(a: Abs): boolean;
-/** 字符串拼接：字面量折叠 + template parts 合并 */
-declare function concatString(a: Abs, b: Abs): Abs;
-
-/**
- * 语言覆盖：class / new / instanceof / this / async await。
- * brand 表示名义类；eff("promise") 表示异步效应。
- *
- * 方法体：ClassDef.methods 存 AST body，调用时在 this=receiver 下求值。
- */
-
-type MethodDef = {
-    name: string;
-    params: string[];
-    body: Node;
-    kind?: string;
-    async?: boolean;
-};
-type ClassDef = {
-    name: string;
-    instanceShape: Abs;
-    ctorParams: string[];
-    methods: Map<string, MethodDef>;
-    superClass?: string;
-};
-declare function defineClass(env: AstEnv, def: ClassDef): void;
-declare function getClass(env: AstEnv, name: string): ClassDef | undefined;
-/** 沿继承链找类 */
-declare function getClassChain(env: AstEnv, name: string): ClassDef[];
-/** new C(...) → brand 实例；并跑 constructor 以写入字段 */
-declare function instantiateClass(env: AstEnv, className: string, args: Abs[], evalBody?: (fn: {
-    params: string[];
-    body: Node;
-}, args: Abs[], thisVal: Abs, env: AstEnv) => Abs): Abs;
-/** 读取当前 this 所属类的父类名 */
-declare function superNameOf(env: AstEnv, className: string): string | undefined;
-/**
- * instanceof：沿继承链匹配 brand 名。
- */
-declare function instanceOf(left: Abs, rightClassName: string, env?: AstEnv): Abs;
-declare function projectBrand(self: Abs, key: string): Abs;
-/** 在 brand 上查找方法定义（含继承） */
-declare function lookupMethod(env: AstEnv, receiver: Abs, methodName: string): MethodDef | undefined;
-/** 沿继承链查找方法，返回定义与所在类名 */
-declare function lookupMethodWithOwner(env: AstEnv, receiver: Abs, methodName: string): {
-    def: MethodDef;
-    owner: string;
-} | undefined;
-/** super.method()：从父类开始找（跳过当前类） */
-declare function lookupSuperMethod(env: AstEnv, receiver: Abs, fromClass: string, methodName: string): {
-    def: MethodDef;
-    owner: string;
-} | undefined;
-declare function wrapPromise(inner: Abs): Abs;
-declare function awaitAbs(v: Abs): Abs;
-declare function coerceAsyncReturn(value: Abs): Abs;
-/** 从 ClassMethod 列表构造 methods map + instance shape */
-declare function classFromMethods(name: string, methods: MethodDef[], superClass?: string, superShape?: Abs): ClassDef;
-
-declare function hashSource(s: string): string;
-declare function resetHashSourceCache(): void;
-
-/**
- * Analysis-stable source key: strip trailing noise that cannot affect types.
- * Keeps every line that may carry @nudo directives.
- *
- * Fast path: already-stable sources return the same string identity (O(1)
- * compare in B-path / analysis caches when the caller reuses the buffer).
- */
-declare function stableAnalyzeKeySource(source: string): string;
-
-/**
- * per-function fingerprint: after-edit only dirty fn + callers miss L0.
- *
- * - own: function declaration slice (incl. leading comments / refine)
- * - deps: transitively referenced sibling own hashes + non-fn top-level context
- * - context change (import/class/const...) -> all miss (conservative)
- *
- * Multi-declarator `const a = fn, b = fn` yields one fingerprint per function;
- * each own-slice is its own declarator (first also carries statement leading comments).
- */
-
-type FnFp = {
-    own: string;
-    deps: string;
-    nRefs: number;
-};
-declare function resetFnFpCache(): void;
-type FnDeclInfo = {
-    name: string;
-    body: Node;
-    /** Function/arrow node (own-slice end; also scanned for sibling refs incl. defaults). */
-    fnNode: Node;
-    /** Declarator start when from a VariableDeclaration; else undefined. */
-    declaratorStart?: number;
-    /** First leading-comment start on this declarator (multi-decl refine/@nudo). */
-    declaratorLeadStart?: number;
-};
-/** Every top-level function binding in a declaration node (not just the first). */
-declare function getFnNameAndBodies(decl: Node): FnDeclInfo[];
-/** source -> (fnName -> own/deps); LRU */
-declare function fnFingerprints(source: string, file: File): Map<string, FnFp>;
-/** L0 source part: per-fn fingerprint when AST available; else full-file hash */
-declare function generalizeSourceKeyPart(source: string, fnName: string, file?: File): string;
+declare function listFunctionNames(source: string): string[];
 /**
- * 无 refine、无模块语法、无兄弟调用、无任何调用表达式 → scanLiteralCalls 可整段跳过。
- * 必须保守：`const x = f(-1)` / `if (f(-1))` / `require("x")` 都含 CallExpression，
- * 只认顶层 ExpressionStatement 会漏报约束违规。
+ * 按 assume 集合构造实参：被 assume 的参数给带约束的符号，其余 any
+ * （design-cli-semantics §2：入口无约束 = any，不是 unknown）。
  */
-declare function canSkipLiteralCallScan(source: string, file: File): boolean;
+declare function buildArgsFromAssume(source: string, fnName: string, assumeIds: Set<string>): Abs[];
 
 /**
- * check 报告面：数据模型 + 渲染/序列化。
+ * 整文件 CheckReport memo（LSP/CI 重复 check → O(1)）。
  *
- * 分析在 check.ts（Abs 优先的 Nudo 原生诊断），这里只投影：
- * - formatCheckReport → 人类可读文本
- * - serializeCheckJson → `nudo check --json` 稳定契约（CI / Agent，v1）
+ * 从 check.ts 拆出的缓存基建：键指纹 / 依赖索引 / 定向逐出 / LRU。
+ * check.ts 通过 re-export 保持 resetCheckSourceMemo /
+ * evictCheckSourceMemoForPaths 对外形状不变。
  */
 
-/** 无损函数签名（类型即计算） */
-type NudoSig = {
-    name: string;
-    params: string[];
-    /** 符号 Abs 本体 */
-    abs: Abs;
-    /** formatAbs 单行 */
-    display: string;
-    /** formatAbsMultiline */
-    detail: string;
-    conf: Confidence;
-};
-type CheckIssue = Diagnostic & {
-    fn?: string;
-    line?: number;
-    column?: number;
-    /** 实参 / 实际值的 Abs 展示 */
-    actual?: string;
-    /** 期望约束（Pred 或 Abs 展示） */
-    expected?: string;
-};
-type CheckReport = {
-    file: string;
-    issues: CheckIssue[];
-    /** 有 error 则 CI 应失败 */
-    ok: boolean;
-    /** Abs 优先的签名表（替代 TS 式 display-only） */
-    signatures: NudoSig[];
-    summary: {
-        errors: number;
-        warnings: number;
-        infos: number;
-        functions: number;
-    };
-};
-/**
- * `nudo check --json` 稳定契约（供 CI / Agent）。
- * 字段只增不改语义；Abs 以 formatAbs 字符串给出，不序列化内部 shape 图。
- */
-type CheckJson = {
-    version: 1;
-    file: string;
-    ok: boolean;
-    summary: CheckReport["summary"];
-    signatures: Array<{
-        name: string;
-        params: string[];
-        display: string;
-        detail: string;
-        conf: string;
-        abs: string;
-    }>;
-    issues: Array<{
-        severity: string;
-        code: string;
-        message: string;
-        fn?: string;
-        line?: number;
-        column?: number;
-        actual?: string;
-        expected?: string;
-        suggestion?: string;
-    }>;
-};
-declare function serializeCheckJson(r: CheckReport): CheckJson;
-/**
- * Nudo 原生报告：Abs 签名表 + actual ⊭ expected。
- * 不是 tsc 输出的换皮。
- */
-declare function formatCheckReport(r: CheckReport, opts?: {
-    verbose?: boolean;
-}): string;
+declare function resetCheckSourceMemo(): void;
+/** `*.nudo.js` 变更后定向逐出依赖它的整文件 check 缓存 */
+declare function evictCheckSourceMemoForPaths(paths: string[]): number;
 
 /**
  * nudo check 门禁：对源码跑代数分析，产出 error/warning。
  *
  * 报告是 **Nudo 原生格式**（Abs 优先），不是 TS 诊断的换皮：
- * - 签名表给出无损 Abs（shape/term/pred/conf）
- * - 违例写清 actual ⊭ expected（实参 Abs vs 前置 Pred）
- * - dts/TS 兼容不是本报告的职责
+ * - 签名表给出无损 Abs（shape/term/pred/conf）+ throws 域
+ * - L1：显式契约 / 调用点证据违例
+ * - L2：export/default/CJS 入口未消化 may-throw → nudo:entry-may-throw
+ * - 违例写清 actual ⊭ expected；成功也打印 signatures
  */
 
-declare function resetCheckSourceMemo(): void;
-/** `*.nudo.js` 变更后定向逐出依赖它的整文件 check 缓存 */
-declare function evictCheckSourceMemoForPaths(paths: string[]): number;
 /**
  * check 选项：core 不碰 fs；host 用 loadModule 喂 require 目标源码。
  */
@@ -1532,11 +1081,40 @@ type CheckOptions = {
     /** 当前文件路径（供 loadModule 解析相对 spec） */
     fromFile?: string;
     /**
-     * 侧车 ambient 绑定开关（host 从 package.json#nudo.interface.autoBind
+     * 侧车 ambient 绑定开关（host 从 package.json#nudo.contract.autoBind
      * 解析后下传；默认 true）。false = check/LSP 执法路径不自动加载侧车
      * （§2.2「整体关闭」承诺覆盖 CI 门禁，不只是打印路径）。
      */
     autoBind?: boolean;
+    /**
+     * 项目根（host 从 findProjectConfig 下传）：树外侧车不 ambient 绑定。
+     * undefined = 不限（node_modules 仍拦）。
+     */
+    projectDir?: string;
+    /**
+     * L2 入口 may-throw 执法档（design-cli-semantics §3）。
+     * error（默认）| warning | off。仅作用于 export/default/CJS 入口函数。
+     */
+    entryThrows?: "error" | "warning" | "off";
+    /** L2 --ignore-throws：按 throws 类型名过滤；不吞 L1 */
+    ignoreThrows?: string[];
+    /** 宿主已求值的依赖导出表（specifier → AbsModuleExports）；
+     *  B 与解释路径共用——import/require 按表解析（CLI 经
+     *  evalAbsModuleGraph 计算后下传） */
+    modules?: Record<string, AbsModuleExports | Record<string, unknown>>;
+    /**
+     * B run 注入包（modules/mocks/envGlobals/replacements/as）——透传
+     * runTranspiled（generalize / L2 / 记录通道 / drift 同源）。memo 键按
+     * 内容指纹（非对象身份）。
+     */
+    inject?: RunTranspiledOptions;
+    /**
+     * `@nudo:skip [returnsExpr]`（host 用 parser 解析后下传）：函数名 → 声明的
+     * 返回 Abs（null = 未声明）。命中函数不评估 body：签名按声明返回上屏
+     * （无声明 → any，不产生 unknown-inference 噪音）；返回契约仍按声明执法；
+     * 入口 may-throw（L2）不评估。调用点参数义务（scan）不受影响。
+     */
+    skips?: ReadonlyMap<string, Abs | null>;
 };
 /**
  * 检查一个文件：
@@ -1568,52 +1146,6 @@ declare function checkSource(filePath: string, source: string, phi?: Phi, opts?:
 /** 字面量 lv 是否落在约束 c 表达的域内（保守：判不了 → false）。 */
 declare function literalMeetsConstraint(lv: number | string | boolean | null, c: NudoConstraint): boolean;
 
-/**
- * Abs inlay hint：把无损约束内联到源码位置。
- * 不是 TS 风格 type annotation 复读，而是 term/pred/conf 的计算结果。
- *
- * 参数侧只展示显式 `@nudo:refine` 契约（entryReqs）——
- * 不从函数体 `if` 反推前置条件（那是控制流，不是对外契约）。
- *
- * A7（design-refine-derivation §8）：default 走 symbolic + entryReqs；
- * 与 CodeLens `● interface` 同源——interfaceTierOf 标注来源；
- * implicit 导出的返回 inlay 标明 `derived`（展示档，非义务契约）。
- */
-
-type AbsInlay = {
-    /** 1-based 行号 */
-    line: number;
-    /** 0-based 列（label 插入点） */
-    character: number;
-    label: string;
-    kind: "type" | "parameter";
-    /** interface 档来源（与 CodeLens `● interface` 同源）；非导出缺省 */
-    interfaceSource?: InterfaceSource;
-    /** true = 隐式推导展示（非义务契约），label 已带 `· derived` */
-    derived?: boolean;
-};
-type CollectAbsInlaysOpts = InterfaceTierOpts & {
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    fromFile?: string;
-};
-/**
- * 收集源码中函数签名的 Abs inlay：
- * - 参数后：仅 `@nudo:refine` / 侧车显式契约（entryReqs）
- * - `{` 前：返回计算形（`x | x * 2`），无 term 时退回 shape
- * - interface 档：导出函数带 `interfaceSource`；implicit 返回标 `derived`
- */
-declare function collectAbsInlays(source: string, opts?: CollectAbsInlaysOpts): AbsInlay[];
-
-/**
- * 指称：Abs → 运行时谓词（设计 §2.7）。
- * - 无 pred：按 shape 检查（typeof / 结构）
- * - 有 pred：在 `term ↦ v` 下检查可判定的数值比较
- * - sum：任一成员
- */
-
-/** Abs 上的运行时守卫表达式（JS boolean 布尔串） */
-declare function denoteGuard(a: Abs, v: string): string;
-
 /**
  * Abs → NudoConstraint 投影（Phase 1，interface 分层推导的生成侧半边）。
  *
@@ -1652,149 +1184,4 @@ declare function absToConstraint(a: Abs): NudoConstraint | undefined;
  */
 declare function joinThenProject(absList: Abs[]): NudoConstraint | undefined;
 
-/**
- * 推导图（derivation trace）side-channel（design-refine-derivation §14.3#6 / §11 Phase 2）。
- *
- * 不叫 provenance：`setProvenanceTracking` 已被 evaluator 的 TypeValue origin map
- * 占用。机制对齐 `setCallCollector` / `setAbsTruncationCollector` 先例——
- * **不进 Abs payload**；ast-eval 与 B-path 共用 core ops（`add` / `joinAbs`），
- * 两条路径天然都覆盖。
- *
- * 设计原则：emit 打印的是推导图的投影，**禁止**事后从最终 Abs 反编译 shift 链。
- * 本模块在 ops 层打点：数值常量加法 → shift 边；joinAbs → join 边。
- * 根约束（手写契约参数）由宿主在入口 Abs 上打 root 标签。
- */
-
-/** 推导节点：边带调用位点 / +k / join；root 携带可打印的约束源表达式 */
-type DerivationNode = {
-    id: number;
-    kind: "root" | "shift" | "join" | "opaque";
-    /** root：宿主给的可读约束表达式（`positive` / `number().gt(0)`） */
-    expr?: string;
-    /** root：跨文件 import 源（相对 specifier，相对 root 侧车目录） */
-    importFrom?: string;
-    /** root：import 绑定名（与 expr 一致时省略） */
-    importName?: string;
-    /** shift：数值偏移 */
-    offset?: number;
-    /** 父节点 id（root 无父） */
-    parents: number[];
-};
-/** 调用位点上的实参推导（供 emit 投影组合式） */
-type ArgDerivation = {
-    node: DerivationNode;
-    /** 从该节点回溯到 root 的路径（含自身，root 在末尾） */
-    chain: DerivationNode[];
-};
-type Collector = (node: DerivationNode) => void;
-/** 设置观察者（null 清除）；缓冲照常累积 */
-declare function setDerivationCollector(fn: Collector | null): void;
-declare function hasDerivationSession(): boolean;
-/** 开始一次推导会话（root 驱动下行求值前调用）；与 end/abort 成对 */
-declare function beginDerivationSession(): void;
-/** 结束会话并取走全部节点（顺序 = 创建序） */
-declare function endDerivationSession(): DerivationNode[];
-/** 丢弃当前会话（求值失败时） */
-declare function abortDerivationSession(): void;
-/**
- * 在入口 Abs 上打 root 标签：该值来自手写契约参数约束。
- * expr 是可打印源（`positive`）；importFrom 指向共享模板侧车。
- */
-declare function tagDerivationRoot(abs: Abs, meta: {
-    expr: string;
-    importFrom?: string;
-    importName?: string;
-}): DerivationNode;
-/** 读取 Abs 上的推导节点（无标签 → undefined） */
-declare function getDerivation(abs: Abs): DerivationNode | undefined;
-/** 手动把推导挂到结果 Abs（宿主在 analyzeFn 返回值上补标签时用） */
-declare function setDerivation(abs: Abs, node: DerivationNode): void;
-/** 从节点回溯 root 路径（含自身；环/缺失截断） */
-declare function derivationChain(node: DerivationNode): DerivationNode[];
-/**
- * ops 层打点：`a + k`（k 为有限数值字面量）且 a 带推导 → 结果挂 shift 节点。
- * 由 arithmetic.add 在返回前调用；无会话/无父标签时 no-op。
- */
-declare function noteDerivationAdd(a: Abs, b: Abs, result: Abs): void;
-/**
- * ops 层打点：join 结果挂 join 节点（任一侧有推导即可）。
- * 工件聚合路径会经 join；check 分轨不依赖 join 节点。
- */
-declare function noteDerivationJoin(inputs: Abs[], result: Abs): void;
-/**
- * 把推导链投影为组合式（§2.4：写组合式，不展开）。
- *
- * 返回 prelude（`const x = positive.shift(1);`）+ expr（`x` / `x.shift(2)`）
- * + 需要的 import。无 root 锚或链上出现 join/opaque → undefined（调用方
- * 退回展开式投影或 not-projectable）。
- */
-declare function projectDerivationDsl(node: DerivationNode, localName: string): {
-    prelude: string[];
-    expr: string;
-    imports: Array<{
-        name: string;
-        from: string;
-    }>;
-} | undefined;
-/** 项结构调试用（测试断言） */
-declare function termKey(t: Term | undefined): string;
-
-/**
- * 源码级调用图侦察：从 check 门禁拆出的 AST 扫描层。
- *
- * 职责：不做代数求值结论，只回答「谁在调用谁、实参长什么样」——
- * - listTopFunctions：顶层函数清单
- * - collectCallResolvers / resolveCalleeFn / collectForwarders：别名 / 对象属性 /
- *   require / 动态 import / 无条件转发 的调用解析
- * - scanLiteralCalls：字面量调用点实参 vs 前置约束的违例收集
- */
-
-/**
- * 注入记录的最小结构面。Abs 为唯一真理源。
- */
-type InjectedDomainRecord = {
-    /** 无损参数 Abs（必填；domain 证据唯一来源） */
-    argAbs?: Abs[];
-    resultAbs?: Abs;
-    throwsAbs?: Abs;
-};
-type InjectedDomainEvidenceOpts = {
-    /** 被调函数形参名（位置序）；契约按参数名对齐证据位 */
-    paramNames: string[];
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    fromFile?: string;
-    /** 侧车 ambient 绑定开关（host 配置下传；默认 true） */
-    autoBind?: boolean;
-    /** 报告定位：被调函数声明处。注入证据的 loc 在使用现场文件，不属于本文件 */
-    loc?: {
-        line: number;
-        column: number;
-    };
-};
-/**
- * 跨文件注入的调用点域证据 vs 手写契约（设计稿 §3.3/§6 对账矩阵第一行）。
- *
- * 来源分流铁律：写在被分析文件里的调用点违例（含 scanLiteralCalls 的
- * checkExternalCall 跨文件被调路径）维持 `nudo:constraint-violated` 原码
- * 原语义——本函数**只**消费经 externalCallRecords 注入的跨文件记录（analyzer
- * 消费区已做归属守卫），该路径此前不查契约，是纯增量。
- *
- * 证据门槛（§6）：
- * - 只有 plain literal 实参构成证据：union/unknown/primitive/refined 形态
- *   无法归因到确定值，不参与。Abs 路径直接读 `litValue` + conf
- *   ∈ {exact, path}。
- * - null 证据预过滤（T4 caveat：lit(null) 编码 prim undefined + eq(self,
- *   null)，对任何约束恒不满足，不过滤必 FP）；undefined/bigint/symbol
- *   不在字面量证据域内，一并跳过；
- * - resultType=never ∧ throws=never 是求值中断泄漏（analyzer 注入消费区
- *   同款过滤；有 resultAbs/throwsAbs 时同口径）。CallRecord 上没有截断字段
- *   （查证于 evaluator.ts CallRecord 声明）——递归截断走
- *   nudo:recursion-truncated 诊断通道且只 widen 结果，不产生新字面量证据；
- * - fn/shape/array 参数位 Phase 1 不执法（§3.3 HOF 豁免：
- *   literalMeetsConstraint 对这些形态恒 false，直接查必 FP）。
- *
- * 每函数每参数位最多一条 issue（多证据并列在 actual 里，去重）。
- */
-declare function checkInjectedDomainEvidence(fnName: string, source: string, records: InjectedDomainRecord[], opts: InjectedDomainEvidenceOpts): CheckIssue[];
-
-export { Abs, type AbsAssignRecord, type AbsCallRecord, type AbsFnImpl, type AbsInlay, AbsModuleExports, type AbsSigImpl, type ArgDerivation, AstEnv, type CheckIssue, type CheckJson, type CheckOptions, type CheckReport, type ClassDef, type CollectAbsInlaysOpts, Confidence, type ConstraintBuilder, type DerivationNode, type Diagnostic, type EffectiveInterface, type EffectiveInterfaceOpts, type Environment, type EvalOptions, type EvalResult, type FnAbs, type FnFp, type FormalParam, type FormatOptions, HofSite, type InjectedDomainRecord, type InterfaceDiag, type InterfaceSource, type InterfaceTierInfo, type InterfaceTierOpts, type LeakBudget, type LeqResult, type LoadDepsFingerprint, MAX_CALL_DEPTH, MAX_TOTAL_CALLS, type MethodDef, type MockHelper, type NamedImport, type NudoConstraint, type NudoField, type NudoFnConstraint, NudoSidecarError, type NudoSig, type ObjShape, Phi, type PolyFn, Pred, PrimName, type RefineDiag, type RefineEntry, type RefineResolveOpts, RelSource, SELF, Shape, type Slot, type TemplateMeta, type TemplatePartDesc, type TemplatePartView, type TemplatePredicateDecision, Term, type TypeParam, abortDerivationSession, absFunction, absShapeKey, absTemplateViews, absToConstraint, add, allFixedTextOfViews, analyzeFn, analyzeFnFull, any, applyAbsFn, array, attachFnImpl, awaitAbs, beginCollectionFork, beginDerivationSession, boolean, buildArgsFromAssume, callAbsMethod, callFunction, callFunctionFull, canSkipLiteralCallScan, checkArg, checkCall, checkInjectedDomainEvidence, checkSource, classFromMethods, clearCollectionTables, cmp, coerceAsyncReturn, collectAbsFreeVars, collectAbsInlays, collectAbsNodeTypes, collectionElementJoin, collectionExactLen, concatString, constraintToEntryAbs, contractParamNameSet, createEnvironment, createTemplateAbs, currentPhi, decideEndsWith, decideIncludes, decideStartsWith, defaultLeakBudget, defineClass, definitelyNotNullishShape, denoteGuard, derivationChain, describePhi, div, effectiveInterface, emptyEnv, endCollectionFork, endDerivationSession, errorBrandAbs, evalArrayStatic, evalBuiltinInstanceMethod, evalBuiltinNew, evalDateCtor, evalDateMethod, evalDateStatic, evalGlobalFn, evalJsonMethod, evalMathMethod, evalMethodBody, evalNamespaceCall, evalNode, evalNumberStatic, evalObjectMethod, evalProgramAbs, evalPromiseCtor, evalPromiseStatic, evalRegExpCtor, evalRegExpMethod, evalSource, evictCheckSourceMemoForPaths, evictGeneralizeMemoForPaths, exceedsBudget, execNudoModule, extractAllLoadSpecs, extractFn, extractNudoImports, extractRefineReturnFromSource, extractRefinesFromSource, falseConstraint, findAbsAtPosition, fixedLengthOfViews, fn, fnConstraintToEntryReqs, fnFingerprints, fnOf, formalParamDisplayNames, formalParamsFromNodes, formatAbs, formatAbsMultiline, formatCheckReport, formatConstraint, formatDiagnostics, formatEffectiveInterfaceDisplay, formatInterfaceTierLine, formatShape, formatShapeSlot, formatTemplateNameViews, generalizeAll, generalizeFromAst, generalizeSourceKeyPart, generatedExportNames, getAbsProperty, getClass, getClassChain, getDerivation, getFnImpl, getFnNameAndBodies, getGeneralizeMemoSize, getParseSourceCacheSize, getSlot, getTerm, hasDerivationSession, hashSource, instanceOf, instantiateClass, instantiateConstraint, interfaceDiagCount, interfaceSourceOf, interfaceTierOf, isErrorCtorName, isIntFlag, isMapAbs, isNodeModulesPath, isNudoConstraint, isNullishLitAbs, isObj, isSetAbs, isTemplateLike, joinAbs, joinFunctions, joinObjects, joinThenProject, joinValues, knownPrefixOfViews, knownSuffixOfViews, leakIfNeeded, lenTerm, leqAbs, listFunctionNames, literalMeetsConstraint, loadModuleDepsFingerprint, localNamedExports, locateContractParam, lookupMethod, lookupMethodWithOwner, lookupSuperMethod, looseEqAbs, makeMapAbs, makeSetAbs, makeSum, mapClearEntries, mapDeleteEntry, mapEntriesAbs, mapGetEntry, mapHasEntry, mapSetEntry, mapSizeAbs, mapValuesAbs, matchRelIdentLit, maybeLeak, mergeAdjacentFixedViews, mergeCollectionArms, mock, mod, mul, negAbs, normPath, notAbs, noteCollectionWrite, noteDerivationAdd, noteDerivationJoin, number, objOf, omit, parseSource, partial, pick, popCollectionArm, popPhi, projectBrand, projectDerivationDsl, pushCollectionArm, pushPhi, refineAbsForRelTrue, refineDiagCount, refineToIndexedFull, relationFingerprint, relationFn, requiredFnArity, resetAbsCallBudget, resetCheckSourceMemo, resetFnFpCache, resetGeneralizeMemo, resetHashSourceCache, resetLeakCounter, resetNudoModuleExecCache, resetParseSourceCache, resetPhi, resolveDepPath, serializeCheckJson, setAbsAssignCollector, setAbsCallCollector, setAbsNodeCollector, setAbsTruncationCollector, setAddEntry, setClearEntries, setDeleteEntry, setDerivation, setDerivationCollector, setElementsAbs, setHasEntry, setInterfaceDiagCollector, setRefineDiagCollector, setSizeAbs, shape, shapeOnlyFn, sidecarClosureFingerprint, sidecarPathOf, sidecarSpecsOf, spread, spy, stableAnalyzeKeySource, strictEqAbs, string, stripTypes, stub, sub, superNameOf, tagDerivationRoot, takeInterfaceDiags, takeInterfaceDiagsSince, takeRefineDiags, takeRefineDiagsSince, templateMatchesValue, templatePartsOf, termDepth, termKey, termNodes, trueConstraint, typeofAbs, union, viewTemplateParts, withPhiConstraint, withVar, wrapPromise };
+export { Abs, type AbsAssignRecord, type AbsCallRecord, type AbsFnImpl, AbsModuleExports, type AbsSigImpl, AstEnv, type CheckOptions, CheckReport, Confidence, EffectiveInterfaceOpts, type Environment, type ExtState, type FnAbs, type FormalParam, type FormatOptions, HofCollectCtx, HofSite, type LeqResult, type MockHelper, NudoConstraint, OBJECT_PROTO_METHOD_NAMES, type ObjShape, Phi, type PolyFn, Pred, type PropFlags, RelSource, RunTranspiledOptions, Shape, type Slot, Term, type TypeParam, absFunction, absShapeKey, absToConstraint, add, alphaOf, applyCallbackAbs, applyCallbackValue, asAbs, assignSourceSlots, attachFnImpl, beginCollectionFork, betaOf, bitandAbs, bitnotAbs, bitorAbs, bitxorAbs, buildArgsFromAssume, builtinCtorAbs, builtinCtorNameOf, callAbsMethod, canonicalArrayIndex, checkSource, clearCollectionTables, cmp, collectAbsFreeVars, collectionElementJoin, collectionExactLen, contractParamNameSet, createEnvironment, createHofCollectCtx, ctorArgDefinitelyInvalid, ctorNameOfRecv, currentPhi, definitelyNotNullishShape, describePhi, div, drainPromiseMicros, emptyEnv, endCollectionFork, enterPromiseExecutorScope, errorBrandAbs, evalArrayStatic, evalBuiltinInstanceMethod, evalBuiltinNew, evalDateCtor, evalDateMethod, evalDateStatic, evalGlobalFn, evalJsonMethod, evalMathMethod, evalNamespaceCall, evalNumberStatic, evalObjectMethod, evalObjectProtoMethod, evalPromiseCtor, evalPromiseMethod, evalPromiseStatic, evalRegExpCtor, evalRegExpMethod, evalStringStatic, evalSymbolCtor, evictCheckSourceMemoForPaths, evictGeneralizeMemoForPaths, extStateOf, extractFn, falseConstraint, fnOf, formalParamDisplayNames, formalParamsFromNodes, formatAbs, formatAbsMultiline, formatShape, formatShapeSlot, generalizeAll, generalizeFromAst, getAbsProperty, getFnImpl, getGeneralizeMemoSize, getPropFlags, getSlot, hostBuiltinCtorName, instantiateReturn, isErrorCtorName, isMapAbs, isNullProtoObj, isNullishLitAbs, isObj, isObjectProtoBrand, isRelFn, isSetAbs, isSymbolAbs, joinAbs, joinFunctions, joinObjects, joinThenProject, joinValues, leavePromiseExecutorScope, leqAbs, listFunctionNames, literalMeetsConstraint, locateContractParam, looseEqAbs, makeArrayCtorAbs, makeMapAbs, makeSetAbs, makeSum, makeSymbolAbs, mapClearEntries, mapDeleteEntry, mapElementFallback, mapEntriesAbs, mapGetEntry, mapHasEntry, mapSetEntry, mapSizeAbs, mapValuesAbs, markExtState, markNullProtoObj, markPureFn, matchRelIdentLit, mergeCollectionArms, migrateInvariants, migrateNullProto, mock, mod, mul, negAbs, notAbs, noteCollectionWrite, notePromiseExecutorFork, objOf, objectProtoBrand, objectProtoMethodAbs, parseSource, popCollectionArm, popPhi, powAbs, projectFlatMapResult, promoteParamShape, protoBrandAbs, protoOfRecv, pureFnNameOf, pushCollectionArm, pushPhi, queuePromiseMicro, refineAbsForRelTrue, regexBrandAbsFrom, relationFingerprint, relationFn, requiredFnArity, resetCheckSourceMemo, resetGeneralizeMemo, resetPhi, setAddEntry, setApplyCallbackHost, setClearEntries, setDeleteEntry, setElementsAbs, setHasEntry, setPropFlags, setSizeAbs, shapeOnlyFn, shlAbs, shrAbs, snapshotAbs, spread, spy, strictEqAbs, stringOfSymbol, stripTypes, stub, sub, substAbs, substPredAbs, symbolDescriptionAbs, symbolIdOf, toNumberAbs, trueConstraint, tryMakeRegexAbs, tryPromoteDirectCall, tryPromoteForOfIteratee, tryPromoteHofCallback, tryPromoteReceiverAsArr, typeofAbs, undefAbs, ushrAbs, withPhiConstraint, withVar };