@nudojs/core 1.0.0 → 2.0.0

package/dist/index.d.ts

@@ -1,195 +1,44 @@
+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 { P as Phi, A as AstEnv, a as Abs, 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-OfNo5qlN.js';
-export { $ as $add, e as $arr, f as $async, g as $asyncReturn, h as $await, i as $call, j as $callNamed, k as $catchVal, l as $class, m as $concat, n as $div, o as $elems, p as $eq, q as $fnVal, r as $for, s as $forIter, t as $forOf, u as $fork, v as $ge, w as $gen, x as $get, y as $gt, z as $idx, B as $idxSet, D as $invoke, E as $invokeSuper, F as $join, G as $le, I as $len, J as $lit, K as $lt, L as $mod, M as $mul, N as $ne, O as $neg, Q as $new, U as $not, V as $obj, W as $optionalGet, X as $optionalInvoke, Y as $orDefault, Z as $regex, _ as $set, a0 as $setKey, a1 as $spread, a2 as $staticInvoke, a3 as $sub, a4 as $super, a5 as $switch, a6 as $thisGet, a7 as $thisSet, a8 as $throw, a9 as $typeof, aa as $while, ab as $whileSeq, ac as $yield, ad as BCallRecord, ae as BClassSpec, af as BMemberDiag, ag as DEFAULT_MAX_LOOP_ITERS, ah as HofCollectCtx, ai as NudoThrow, aj as RunTranspiledOptions, ak as TranspileOptions, al as TranspiledCallResult, am as abs, an as absToString, ao as alphaOf, ap as and, aq as anyVar, ar as app, as as applyCallbackAbs, at as asAbs, au as asAbsVal, av as betaOf, aw as bindImports, ax as bool, ay as boolLit, az as callTranspiledExport, aA as callTranspiledExportFull, aB as clearBClasses, aC as collectAbsExports, aD as confJoin, aE as createHofCollectCtx, aF as currentExecPhi, aG as emptyPhi, aH as eq, aI as ge, aJ as geNum, aK as getAbsOrigin, aL as getBCallCollector, aM as getBClass, aN as gt, aO as gtNum, aP as implies, aQ as instantiateReturn, aR as isDefinitelyFalse, aS as isDefinitelyTrue, aT as isExactLit, aU as isNudoThrow, aV as isNumPrim, aW as isRelFn, aX as isStrPrim, aY as le, aZ as leNum, a_ as lit, a$ as litTruth, b0 as litValue, b1 as lt, b2 as ltNum, b3 as mapElementFallback, b4 as namespaceNameOf, b5 as ne, b6 as never, b7 as not, b8 as noteMemberDispatchMiss, b9 as notePrimMemberMissing, ba as noteUnknownMemberMissing, bb as num, bc as numLit, bd as numVar, be as obj, bf as or, bg as pFalse, bh as pTrue, bi as phiAnd, bj as predEquals, bk as predToString, bl as predVars, bm as projectFlatMapResult, bn as promoteParamShape, bo as ptypeof, bp as recordMemberDiag, bq as registerBClass, br as runTranspiled, bs as setApplyCallbackHost, bt as setBCallCollector, bu as setMemberDiagCollector, bv as shapeOfTerm, bw as shapeToString, bx as simplifyTerm, by as snapshotAbs, bz as str, bA as strLit, bB as substAbs, bC as substPred, bD as substPredAbs, bE as tagAbsOrigin, bF as termEquals, bG as termToString, bH as transpile, bI as transpileExpression, bJ as transpileFile, bK as transpileSource, bL as tryPromoteDirectCall, bM as tryPromoteForOfIteratee, bN as tryPromoteHofCallback, bO as tryPromoteReceiverAsArr, bP as undefAbs, bQ as unknown, bR as v, bS as withExecPhi } from './index-OfNo5qlN.js';
 
 type Environment = {
-    lookup(name: string): TypeValue;
-    bind(name: string, value: TypeValue): Environment;
-    update(name: string, value: TypeValue): boolean;
-    extend(bindings: Record<string, TypeValue>): Environment;
+    lookup(name: string): Abs;
+    bind(name: string, value: Abs): Environment;
+    update(name: string, value: Abs): boolean;
+    extend(bindings: Record<string, Abs>): Environment;
     fork(): Environment;
     has(name: string): boolean;
     snapshot(): Environment;
-    getOwnBindings(): Record<string, TypeValue>;
+    getOwnBindings(): Record<string, Abs>;
 };
-declare function createEnvironment(parent?: Environment, bindings?: Map<string, TypeValue>): Environment;
-
-type LiteralValue = string | number | boolean | bigint | null | undefined;
-type SigImpl = (args: TypeValue[], thisVal?: TypeValue) => TypeValue | undefined;
-type FunctionSignature = {
-    paramTypes: TypeValue[];
-    returnType: TypeValue;
-    throwsType: TypeValue;
-    impl?: SigImpl;
-};
-type Refinement = {
-    name: string;
-    meta: Record<string, unknown>;
-    check?: (value: unknown) => boolean;
-    ops?: Record<string, (self: TypeValue, other: TypeValue) => TypeValue | undefined>;
-    methods?: Record<string, (self: TypeValue, args: TypeValue[]) => TypeValue | undefined>;
-    properties?: Record<string, (self: TypeValue) => TypeValue | undefined>;
-};
-type TypeValue = {
-    kind: "literal";
-    value: LiteralValue;
-} | {
-    kind: "primitive";
-    type: "number" | "string" | "boolean" | "bigint" | "symbol";
-} | {
-    kind: "refined";
-    base: TypeValue;
-    refinement: Refinement;
-} | {
-    kind: "object";
-    properties: Record<string, TypeValue>;
-    id: symbol;
-} | {
-    kind: "array";
-    element: TypeValue;
-} | {
-    kind: "tuple";
-    elements: TypeValue[];
-} | {
-    kind: "function";
-    params: string[];
-    body: Node;
-    closure: Environment;
-} | {
-    kind: "promise";
-    value: TypeValue;
-} | {
-    kind: "instance";
-    className: string;
-    properties: Record<string, TypeValue>;
-} | {
-    kind: "union";
-    members: TypeValue[];
-} | {
-    kind: "never";
-} | {
-    kind: "unknown";
-};
-declare function createUnion(...members: TypeValue[]): TypeValue;
-declare const T: {
-    readonly literal: (value: LiteralValue) => TypeValue;
-    readonly number: TypeValue;
-    readonly string: TypeValue;
-    readonly boolean: TypeValue;
-    readonly bigint: TypeValue;
-    readonly symbol: TypeValue;
-    readonly null: TypeValue;
-    readonly undefined: TypeValue;
-    readonly unknown: TypeValue;
-    readonly never: TypeValue;
-    readonly object: (properties: Record<string, TypeValue>) => TypeValue;
-    readonly array: (element: TypeValue) => TypeValue;
-    readonly tuple: (elements: TypeValue[]) => TypeValue;
-    readonly promise: (value: TypeValue) => TypeValue;
-    readonly instanceOf: (className: string, properties?: Record<string, TypeValue>) => TypeValue;
-    readonly union: typeof createUnion;
-    readonly fn: (params: string[], body: Node, closure: Environment) => TypeValue;
-    readonly refine: (base: TypeValue, refinement: Refinement) => TypeValue;
-    readonly fnSig: (paramTypes: TypeValue[], returnType: TypeValue, throwsType?: TypeValue, impl?: SigImpl) => TypeValue;
-};
-declare function typeValueEquals(a: TypeValue, b: TypeValue): boolean;
-declare function simplifyUnion(members: TypeValue[]): TypeValue;
-declare function widenLiteral(tv: TypeValue): TypeValue;
-/**
- * union 成员全部为同原语基底的字面量且数量 > maxLiterals 时塌缩为该基类型；
- * 非 union、混合类型、或数量不超限的原样返回。
- *
- * 复用 simplifyUnion（内含吸收律与去重）：先让「基类型已在场」的字面量被吸收
- * （3 | number → number），再对剩余的纯字面量联合做阈值坍缩（1|2|…|20 → number）。
- * 两步不冲突也不重复：吸收只删基类型已在场的字面量，阈值坍缩只处理无基类型
- * 在场的纯字面量联合。
- */
-declare function collapseLiteralUnion(tv: TypeValue, maxLiterals: number): TypeValue;
-declare function isSubtypeOf(a: TypeValue, b: TypeValue): boolean;
-declare function deepCloneTypeValue(tv: TypeValue, idMap?: Map<symbol, symbol>): TypeValue;
-declare function mergeObjectProperties(a: TypeValue & {
-    kind: "object";
-}, b: TypeValue & {
-    kind: "object";
-}): TypeValue;
-declare function typeValueToString(tv: TypeValue): string;
-declare function narrowType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
-declare function subtractType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
-declare function getPrimitiveTypeOf(tv: TypeValue): string | undefined;
-declare function getRefinedBase(tv: TypeValue): TypeValue;
-declare function isFnSig(tv: TypeValue): boolean;
-declare function getFnSig(tv: TypeValue): FunctionSignature | undefined;
-
-/**
- * 残差 IR 兜底（不是类型运算真理源）。
- *
- * 真理在 algebra：算术/比较/相等/typeof/!/−/字符串词法序/nullish 均走 Abs。
- * 这里只保留：
- * - add：代数拒绝时的混合 `+`
- * - 比较/相等：代数无法判定时的保守 boolean / 字面量折叠
- * - dispatchMethod/Property：宿主 refined 扩展（startsWith、length…）
- */
-
-declare const Ops: {
-    readonly add: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly strictEq: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly strictNeq: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly gt: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly lt: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly gte: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly lte: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly not: (operand: TypeValue) => TypeValue;
-};
-declare function applyBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
-declare function dispatchBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
-declare function dispatchMethod(receiver: TypeValue, name: string, args: TypeValue[]): TypeValue | undefined;
-declare function dispatchProperty(receiver: TypeValue, name: string): TypeValue | undefined;
-
-/**
- * 模板字面量谓词，独立于 template.ts 以断开运行时循环引用：
- * type-value.ts（联合吸收律）与 template.ts 都依赖本模块，而本模块对
- * type-value.ts 只有 `import type` 边（编译后消失），运行时依赖保持单向
- * type-value.ts / template.ts -> template-predicates.ts。
- */
-declare function isTemplate(tv: TypeValue): boolean;
-
-declare function createTemplate(parts: TypeValue[]): TypeValue;
-
-declare function getTemplateParts(tv: TypeValue): TypeValue[] | undefined;
-declare function concatTemplates(left: TypeValue, right: TypeValue): TypeValue;
-
-type RangeMeta = {
-    min?: number;
-    max?: number;
-    /** 下界开区间：value > min（JS 实数，不能写成 >= min+1） */
-    minExclusive?: boolean;
-    /** 上界开区间：value < max */
-    maxExclusive?: boolean;
-    integer?: boolean;
-};
-declare function createRange(meta: RangeMeta): TypeValue;
-declare function isRange(tv: TypeValue): boolean;
-declare function getRangeMeta(tv: TypeValue): RangeMeta | undefined;
+declare function createEnvironment(parent?: Environment, bindings?: Map<string, Abs>): Environment;
 
 /**
  * Nudo Mock 帮助函数
  *
- * 提供类型安全的 mock 创建，替代 sinon 表达式
+ * 提供类型安全的 mock 创建，替代 sinon 表达式。
+ * 值字段为 Abs（类型系统真理源）。
+ * Abs 路径经 mock-abs.ts / mockDirectivesToAbsSeeds 消费。
  */
 
 type MockHelper = {
     kind: "mock-helper";
-    returnValue?: TypeValue;
-    resolvedValue?: TypeValue;
-    rejectedValue?: TypeValue;
-    implementation?: (...args: TypeValue[]) => TypeValue;
-    onFirstCallValue?: TypeValue;
-    onSecondCallValue?: TypeValue;
+    returnValue?: Abs;
+    resolvedValue?: Abs;
+    rejectedValue?: Abs;
+    onFirstCallValue?: Abs;
+    onSecondCallValue?: Abs;
     withArgsCases?: {
-        args: TypeValue[];
-        returnValue: TypeValue;
+        args: Abs[];
+        returnValue: Abs;
     }[];
-    callsFakeImpl?: TypeValue;
+    /** callsFake 的函数体（AST）；params 同步存下供 Abs absFunction */
+    callsFakeImpl?: {
+        params: string[];
+        body: Node;
+        async?: boolean;
+    };
 };
 /**
  * 创建一个 stub mock
@@ -197,13 +46,17 @@ type MockHelper = {
  */
 declare function stub(): MockHelper;
 declare namespace stub {
-    var returns: (value: TypeValue) => MockHelper;
-    var resolves: (value: TypeValue) => MockHelper;
-    var rejects: (value: TypeValue) => MockHelper;
-    var onFirstCall: (value: TypeValue) => MockHelper;
-    var onSecondCall: (value: TypeValue) => MockHelper;
-    var withArgs: (...args: TypeValue[]) => MockHelper;
-    var callsFake: (fn: TypeValue) => MockHelper;
+    var returns: (value: Abs) => MockHelper;
+    var resolves: (value: Abs) => MockHelper;
+    var rejects: (value: Abs) => MockHelper;
+    var onFirstCall: (value: Abs) => MockHelper;
+    var onSecondCall: (value: Abs) => MockHelper;
+    var withArgs: (...args: Abs[]) => MockHelper;
+    var callsFake: (fn: {
+        params: string[];
+        body: Node;
+        async?: boolean;
+    }) => MockHelper;
 }
 /**
  * 创建一个 spy mock
@@ -211,17 +64,13 @@ declare namespace stub {
  */
 declare function spy(): MockHelper;
 declare namespace spy {
-    var returns: (value: TypeValue) => MockHelper;
+    var returns: (value: Abs) => MockHelper;
 }
 /**
  * 创建一个 mock
  * 用法: @nudo:mock service = mock()
  */
 declare function mock(): MockHelper;
-/**
- * 将 MockHelper 转换为 TypeValue
- */
-declare function mockHelperToTypeValue(helper: MockHelper, env: Environment): TypeValue;
 
 /**
  * 原地剥除 AST 中的 TS-only 语法节点/字段，返回同一棵 AST（便于链式使用）。
@@ -256,6 +105,8 @@ declare function describePhi(): string;
  * 与 term-registry 同一纪律：不给共享单例挂 impl。
  */
 
+/** Abs 原生 env/builtin 实现（B-path 优先） */
+type AbsSigImpl = (args: Abs[], thisVal?: Abs) => Abs | undefined;
 type AbsFnImpl = {
     params: string[];
     /** 可选：无 body 时走 relation（纯关系 fn） */
@@ -266,6 +117,12 @@ type AbsFnImpl = {
     kind?: string;
     /** 调用时直接派发（mock withArgs 等），优先于 body */
     apply?: (args: Abs[]) => Abs;
+    /**
+     * 对象方法（ObjectMethod / 方法型 FunctionExpression）：$invoke 时把
+     * receiver 作为 apply 的**首参**注入。shape.params 仍是用户可见形参
+     * （不含 receiver），自由调用不注入 → this 为 unbound（JS 语义）。
+     */
+    bindThis?: boolean;
     /**
      * Optional content key for cache fingerprints. formatAbs cannot see
      * WeakMap-side mock semantics (returns/withArgs/callsFake), so hosts that
@@ -372,12 +229,18 @@ declare function negAbs(a: Abs, _phi?: Phi): Abs;
 declare function notAbs(a: Abs): Abs;
 /** 该 shape 在 JS 上一定不是 null/undefined */
 declare function definitelyNotNullishShape(s: Shape): boolean;
+/** 仅当 term 确为 lit null/undefined 时为 true；非 lit 的 litValue===undefined 不得当 nullish */
 declare function isNullishLitAbs(a: Abs): boolean;
 /**
  * 严格相等（Abs）：双字面量折叠；nullish 与 definitely-not-nullish → false。
  * 返回 undefined = 无法判定（交给 boolean + 调用方）。
  */
 declare function strictEqAbs(a: Abs, b: Abs): boolean | undefined;
+/**
+ * 宽松相等 `==`（C2.3）：双 lit 走 Abstract Equality；否则回落严格相等判定。
+ * 返回 undefined = 无法判定。
+ */
+declare function looseEqAbs(a: Abs, b: Abs): boolean | undefined;
 
 /**
  * Abs 侧常用 builtin：shape 级运算，不依赖 TypeValue host 库。
@@ -408,6 +271,12 @@ declare function evalPromiseCtor(_args: Abs[]): Abs;
 declare function evalPromiseStatic(name: string, args: Abs[]): Abs | undefined;
 /** 命名空间分派入口 */
 declare function evalNamespaceCall(ns: string, method: string, args: Abs[]): Abs | undefined;
+declare function isErrorCtorName(name: string | undefined): boolean;
+/**
+ * Error brand：shape 带 name/message（字面量 message 保精确）。
+ * $new 与 ast-eval 的 new Error 共用——catch 形参成员访问可解。
+ */
+declare function errorBrandAbs(name: string, messageArg?: Abs): Abs;
 /** new X(...) */
 declare function evalBuiltinNew(className: string, args: Abs[]): Abs | undefined;
 /** brand 实例方法（Date/RegExp/Map/Set） */
@@ -498,9 +367,10 @@ declare function spread(base: Abs, over: Abs): Abs;
  * 同 key 集：槽位级 join（字面量并）；异 key 集：保持 sum。
  */
 declare function joinObjects(a: Abs, b: Abs): Abs;
-/** 值级 join：字面量保留为… Phase A 对 prim 做 term 保留策略 */
+/** 值级 join：同型双字面量保留为枚举 sum；其余 prim 同型收成 path */
 declare function joinValues(a: Abs, b: Abs): Abs;
 declare function makeSum(a: Abs, b: Abs): Abs;
+declare function absShapeKey(a: Abs, seen?: Set<object>): string;
 type FnAbs = Abs & {
     shape: {
         k: "fn";
@@ -520,6 +390,86 @@ declare function joinFunctions(a: Abs, b: Abs): Abs;
 /** 通用 join：分派到对象/函数/值 */
 declare function joinAbs(a: Abs, b: Abs): Abs;
 
+/**
+ * Map / Set 字面量条目追踪（C1.1 / C1.2）。
+ * 按 Abs 对象身份挂 side table：`m.set("k", v)` 后同 identity 的 `m.get("k")`
+ * 可回查。非字面量 key 不入表；get/has 对未知 key 保守回落。
+ */
+
+type LitKey = string | number | boolean | null | undefined;
+type MapTable = {
+    byLit: Map<LitKey, Abs>;
+    /** 非字面量 key 写入的值（get 未知 key 时 join 用） */
+    shadowValues: Abs[];
+    /** 抽象分支并入后「可能不存在」的字面量键（get/has 需保守） */
+    maybeAbsent?: Set<LitKey>;
+};
+type SetTable = {
+    elements: Abs[];
+    /**
+     * fork 后 membership 不确定。
+     * - `true`：整表不确定（未知 delete / 非字面量元素混杂）
+     * - `Set<LitKey>`：这些字面 key 可能在部分臂缺失（跨臂 delete 不同元素时，长度启发式不够）
+     */
+    maybeAbsent?: true | Set<LitKey>;
+};
+/** $fork 抽象分支：每侧独立 overlay，避免身份表被另一侧 set 污染 */
+type ArmOverlay = WeakMap<object, {
+    map?: MapTable;
+    set?: SetTable;
+}>;
+declare function pushCollectionArm(): void;
+declare function popCollectionArm(): ArmOverlay | undefined;
+/**
+ * 合并 fork 各臂 overlay → 全局表（由 endCollectionFork 实现）。
+ * 保留导出名以免外部测试/调用点漂移。
+ */
+declare function mergeCollectionArms(arms: Array<ArmOverlay | undefined>): void;
+declare function beginCollectionFork(): void;
+declare function noteCollectionWrite(id: object): void;
+declare function endCollectionFork(arms: Array<ArmOverlay | undefined>): void;
+declare function isMapAbs(a: Abs | undefined): boolean;
+declare function isSetAbs(a: Abs | undefined): boolean;
+declare function makeMapAbs(iterable?: Abs): Abs;
+declare function makeSetAbs(iterable?: Abs): Abs;
+/** Map#set：fork 内写 overlay；否则原地。返回同一 Abs（JS 可变语义） */
+declare function mapSetEntry(mapAbs: Abs, key: Abs | undefined, value: Abs): Abs;
+/** Map#delete：fork overlay 内移除字面量键；未知 key 仅标 shadow 不确定 */
+declare function mapDeleteEntry(mapAbs: Abs, key: Abs | undefined): Abs;
+/** Map#clear：清空条目；fork 下仍走 overlay */
+declare function mapClearEntries(mapAbs: Abs): Abs;
+/** Map#get：命中字面量 key → 精确；miss / 未知 key / maybeAbsent / shadow 并 undefined */
+declare function mapGetEntry(mapAbs: Abs, key: Abs | undefined): Abs;
+/** Map#has：字面量 miss 折 exact false 时，get 必须是 undefined（不可再并 value） */
+declare function mapHasEntry(mapAbs: Abs, key: Abs | undefined): Abs;
+declare function mapSizeAbs(mapAbs: Abs): Abs;
+declare function mapValuesAbs(mapAbs: Abs): Abs[];
+/**
+ * Map 迭代条目：JS `for (const [k,v] of map)` / `Array.from(map)` 产出
+ * `[key, value]` 元组 Abs。字面量 key 精确；shadow 写入 key 为 unknown。
+ */
+declare function mapEntriesAbs(mapAbs: Abs): Abs[];
+/** Set#add：fork 内写 overlay；返回同一 Abs */
+declare function setAddEntry(setAbs: Abs, value: Abs): Abs;
+/** Set#delete：按字面量元素移除；fork overlay 内生效。
+ * 字面量删除且无残留非字面量元素 → 该臂可精确 miss；
+ * 臂间分歧由 endCollectionFork 按元素数差标 maybeAbsent。 */
+declare function setDeleteEntry(setAbs: Abs, value: Abs): Abs;
+/** Set#clear */
+declare function setClearEntries(setAbs: Abs): Abs;
+declare function setHasEntry(setAbs: Abs, value: Abs): Abs;
+declare function setSizeAbs(setAbs: Abs): Abs;
+declare function setElementsAbs(setAbs: Abs): Abs[];
+/**
+ * 确切条目数：Set 无 maybeAbsent / Map 无 shadow+maybeAbsent 时返回长度；
+ * 否则 undefined（for-of 不得假装有界）。
+ */
+declare function collectionExactLen(c: Abs): number | undefined;
+/** 元素联合（for-of / Array.from）；无表 → unknown。
+ *  Map 语义是 entry `[k,v]` 元组联合，不是裸 value。 */
+declare function collectionElementJoin(c: Abs): Abs;
+declare function clearCollectionTables(): void;
+
 /**
  * 结构可赋值：src ≤ tgt（Abs 上的 leq）。
  *
@@ -559,6 +509,13 @@ type EvalOptions = {
     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;
@@ -577,7 +534,8 @@ type AbsCallRecord = {
     };
     threw?: boolean;
 };
-declare function setAbsCallCollector(collector: ((r: AbsCallRecord) => void) | null): void;
+/** 设置收集器并返回先前值（嵌套/并发宿主须 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;
 /** 赋值记录：结构可赋值检查用 */
 type AbsAssignRecord = {
@@ -602,11 +560,19 @@ type EvalResult = {
     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 源码。
@@ -617,6 +583,18 @@ 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 下求值方法体。
@@ -647,6 +625,18 @@ declare function applyAbsFn(fnVal: Abs, args: Abs[], env: AstEnv, phi: Phi, budg
  * `, "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 时出现。
@@ -805,6 +795,8 @@ declare function isIntFlag(c: NudoConstraint): boolean;
 declare function number(): ConstraintBuilder;
 declare function string(): ConstraintBuilder;
 declare function boolean(): ConstraintBuilder;
+/** any() —— 无约束；formatConstraint / draft import 与显示同源 */
+declare function any(): ConstraintBuilder;
 /** array(item) —— 数组，元素满足 item */
 declare function array(item: NudoConstraint | ConstraintBuilder): ConstraintBuilder;
 /**
@@ -976,18 +968,22 @@ declare function takeInterfaceDiagsSince(since: number): InterfaceDiag[];
 /** 有效契约来源：手写（源码 refine ∪ 侧车手写绑定）> 生成段 > 隐式 */
 type InterfaceSource = "handwritten" | "generated" | "implicit";
 /**
- * 源文件本地 named export 表：收集本文件声明并导出的名字——
- * `export function/const/let/var/class` 声明形式，以及本地列表
- * `export { x }` / `export { local as exported }`（按**导出名**绑定，
- * 与侧车同名自动绑定口径一致）。
- * 排除 re-export（`export {x} from` / `export *`）与 `export default`。
+ * 源文件本地导出名表（侧车自动绑定边界）：
+ * - 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>;
 /**
- * 侧车源码的生成段导出名：导出名所在声明的**前置注释块**含 `@generated`
- * 标记（emit 产物 canonical 注释为 `@generated by nudo`）→ 该名为 generated。
- * Phase 1 简化：只看紧邻声明上方的注释块（与 extractRefineLines 同款反向
- * 行扫描，空行可跨）；隔了代码行 / 无标记 / re-export 列表均不算。
+ * 侧车源码的生成段导出名：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 & {
@@ -1028,10 +1024,109 @@ declare function effectiveInterface(source: string, fnName: string, opts?: Effec
 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` 参数名与求值形参的对齐基线。
+ *
+ * - Identifier / 默认参（AssignmentPattern left）→ 绑定名
+ * - RestElement → 契约名用裸名（`args`），展示名 `...args`
+ * - ObjectPattern / ArrayPattern → 求值占位 `_p{i}`；契约面 = 顶层绑定名
+ *   （对象属性 / 数组元素 Identifier）。嵌套 pattern 的绑定名标 `nested`，
+ *   消费方可显式降级（C4.5 param-mismatch / 不执法）。
+ */
+type FormalParam = {
+    kind: "id";
+    name: string;
+    index: number;
+} | {
+    kind: "default";
+    name: string;
+    index: number;
+} | {
+    kind: "rest";
+    name: string;
+    display: string;
+    index: number;
+} | {
+    kind: "pattern";
+    /** 求值/签名占位名（generalize 与 dts 用） */
+    placeholder: string;
+    /** 顶层可表达绑定名（侧车契约面） */
+    bound: string[];
+    /**
+     * 契约名 → 对象属性键。rename `{a: b}` 时契约可写 a 或 b，
+     * 投影必须用属性键 a（Abs 对象只有 slot a）。
+     */
+    propKey: Record<string, string>;
+    /** 仅嵌套内出现、顶层不可单独表达的名（降级用） */
+    nested: string[];
+    index: number;
+};
+type AstParam = {
+    type: string;
+    name?: string;
+    left?: AstParam;
+    right?: unknown;
+    argument?: AstParam;
+    properties?: Array<{
+        key?: AstParam;
+        value?: AstParam;
+        type?: string;
+        argument?: AstParam;
+    }>;
+    elements?: Array<AstParam | null | undefined>;
+};
+declare function formalParamsFromNodes(params: AstParam[] | undefined | null): FormalParam[];
+/** 求值/签名用形参名（与 analyzer extractParamNames / dts 对齐） */
+declare function formalParamDisplayNames(formals: FormalParam[]): string[];
+/** 侧车契约可绑定的参数名全集 */
+declare function contractParamNameSet(formals: FormalParam[]): Set<string>;
+/**
+ * 契约参数名 → 形参定位。
+ * - 命中 id/default/rest → 该 index（执法按整参）
+ * - 命中 pattern 顶层 bound 名 → 该 pattern index + field
+ * - 命中 placeholder / `_` → pattern index（整对象）
+ * - 未命中 → undefined（C4.5 param-mismatch）
+ */
+declare function locateContractParam(formals: FormalParam[], contractName: string): {
+    index: number;
+    field?: string;
+    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;
 };
@@ -1069,6 +1164,8 @@ declare function getGeneralizeMemoSize(): number;
  * 返回删除的条目数。路径需与 generalize 时 resolveDepPath 形态一致（建议先 norm）。
  */
 declare function evictGeneralizeMemoForPaths(paths: string[]): number;
+/** 公开：收集 Abs 自由 term 变元（dts 泛型投影 / α 作用域判定复用 L2 基建）。 */
+declare function collectAbsFreeVars(a: Abs): Set<string>;
 type TypeParam = {
     id: string;
     value: Abs;
@@ -1085,6 +1182,11 @@ type PolyFn = {
         param: string;
         pred: Pred;
     }>;
+    /**
+     * 形参表面（C4.1）：默认/rest/解构的契约可绑定名。
+     * 与 params（求值展示名）并列；检查/侧车匹配走 formals。
+     */
+    formals?: FormalParam[];
     /**
      * 函数形参的符号外延（与 typeParams 同 α 空间）。
      * symbolic 一次跑正常结束时从 env 快照拷出；instantiate 重跑不写。
@@ -1107,6 +1209,7 @@ declare function extractFn(source: string, fnName: string, fileAst?: ReturnType<
     params: string[];
     body: Node;
     env: AstEnv;
+    formals: FormalParam[];
 } | undefined;
 declare function generalizeFromAst(fnName: string, source: string, opts?: {
     budget?: LeakBudget;
@@ -1162,7 +1265,7 @@ declare function formatDiagnostics(diags: Diagnostic[]): string;
  *
  * 本模块是模板语义的唯一真理源：前缀/后缀/固定文本/长度/匹配/名称渲染/
  * 相邻合并/谓词判定等纯计算以「中性 part 视图」（TemplatePartView）暴露；
- * TypeValue 侧（refinements/template.ts）与 Abs 方法表（methods.ts）只做薄适配。
+ * Abs 方法表（methods.ts）只做薄适配。
  */
 
 type TemplateMeta = {
@@ -1197,7 +1300,7 @@ declare function formatTemplateNameViews(views: TemplatePartView[]): string;
 declare function mergeAdjacentFixedViews<P>(views: TemplatePartView<P>[], rebuildFixed: (text: string) => TemplatePartView<P>): TemplatePartView<P>[];
 /** 具体字符串是否匹配模板（Refinement.check 的判定语义） */
 declare function templateMatchesValue(value: string, views: TemplatePartView[]): boolean;
-/** 三值判定；两侧分别把 "unknown" 适配为 boolPrim（Abs）或 undefined（TypeValue） */
+/** 三值判定；Abs 方法表把 "unknown" 适配为 boolPrim */
 type TemplatePredicateDecision = boolean | "unknown";
 declare function decideStartsWith(prefix: string, search: string): TemplatePredicateDecision;
 declare function decideEndsWith(suffix: string, search: string): TemplatePredicateDecision;
@@ -1467,7 +1570,12 @@ declare function literalMeetsConstraint(lv: number | string | boolean | null, c:
  *
  * 参数侧只展示显式 `@nudo:refine` 契约（entryReqs）——
  * 不从函数体 `if` 反推前置条件（那是控制流，不是对外契约）。
+ *
+ * A7（design-refine-derivation §8）：default 走 symbolic + entryReqs；
+ * 与 CodeLens `● interface` 同源——interfaceTierOf 标注来源；
+ * implicit 导出的返回 inlay 标明 `derived`（展示档，非义务契约）。
  */
+
 type AbsInlay = {
     /** 1-based 行号 */
     line: number;
@@ -1475,16 +1583,22 @@ type AbsInlay = {
     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` 声明的前置契约
+ * - 参数后：仅 `@nudo:refine` / 侧车显式契约（entryReqs）
  * - `{` 前：返回计算形（`x | x * 2`），无 term 时退回 shape
+ * - interface 档：导出函数带 `interfaceSource`；implicit 返回标 `derived`
  */
-declare function collectAbsInlays(source: string, refineOpts?: {
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    fromFile?: string;
-}): AbsInlay[];
+declare function collectAbsInlays(source: string, opts?: CollectAbsInlaysOpts): AbsInlay[];
 
 /**
  * 指称：Abs → 运行时谓词（设计 §2.7）。
@@ -1496,28 +1610,6 @@ declare function collectAbsInlays(source: string, refineOpts?: {
 /** Abs 上的运行时守卫表达式（JS boolean 布尔串） */
 declare function denoteGuard(a: Abs, v: string): string;
 
-/**
- * Abs ⇄ TypeValue 桥。
- *
- * 纪律：
- * - absToTypeValue 有损：丢 term/pred 时 conf 降为 widened，禁止假装 exact
- * - typeValueToAbs 尽量恢复 term=lit
- * - 下游（dts/lsp/service）吃 TypeValue；代数运算吃 Abs
- */
-
-declare function setTvConfidence(tv: TypeValue, conf: Confidence): void;
-declare function getTvConfidence(tv: TypeValue): Confidence | undefined;
-/**
- * Abs → TypeValue（给下游）。
- * 有损：非 lit term 丢弃；pred 尽量 encode 成 refined，否则丢。
- */
-declare function absToTypeValue(a: Abs): TypeValue;
-/**
- * TypeValue → Abs（给代数运算）。
- * 置信度：优先读 abs→tv 时挂上的 conf 旁路，避免 #widened 回升 #exact。
- */
-declare function typeValueToAbs(tv: TypeValue): Abs;
-
 /**
  * Abs → NudoConstraint 投影（Phase 1，interface 分层推导的生成侧半边）。
  *
@@ -1556,6 +1648,93 @@ 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 扫描层。
  *
@@ -1567,13 +1746,13 @@ declare function joinThenProject(absList: Abs[]): NudoConstraint | undefined;
  */
 
 /**
- * 注入记录的最小结构面（service CallRecord 的成员子集——core 不反向依赖
- * service 的 CallRecord 声明，按结构兼容接收）。
+ * 注入记录的最小结构面。Abs 为唯一真理源。
  */
 type InjectedDomainRecord = {
-    argTypes: TypeValue[];
-    resultType: TypeValue;
-    throws: TypeValue;
+    /** 无损参数 Abs（必填；domain 证据唯一来源） */
+    argAbs?: Abs[];
+    resultAbs?: Abs;
+    throwsAbs?: Abs;
 };
 type InjectedDomainEvidenceOpts = {
     /** 被调函数形参名（位置序）；契约按参数名对齐证据位 */
@@ -1598,15 +1777,14 @@ type InjectedDomainEvidenceOpts = {
  *
  * 证据门槛（§6）：
  * - 只有 plain literal 实参构成证据：union/unknown/primitive/refined 形态
- *   无法归因到确定值，不参与（widened/partial conf 经 absToTypeValue 投影
- *   为非 literal 形态，天然被此条排除；getTvConfidence 再兜一道底）；
+ *   无法归因到确定值，不参与。Abs 路径直接读 `litValue` + conf
+ *   ∈ {exact, path}。
  * - null 证据预过滤（T4 caveat：lit(null) 编码 prim undefined + eq(self,
  *   null)，对任何约束恒不满足，不过滤必 FP）；undefined/bigint/symbol
  *   不在字面量证据域内，一并跳过；
  * - resultType=never ∧ throws=never 是求值中断泄漏（analyzer 注入消费区
- *   同款过滤）。CallRecord 上没有截断字段（查证于 evaluator.ts CallRecord
- *   声明：fnName/argTypes/resultType/throws/callLoc/targetModule/
- *   targetExport/targetAliases/fnModule 十项，无截断标记）——递归截断走
+ *   同款过滤；有 resultAbs/throwsAbs 时同口径）。CallRecord 上没有截断字段
+ *   （查证于 evaluator.ts CallRecord 声明）——递归截断走
  *   nudo:recursion-truncated 诊断通道且只 widen 结果，不产生新字面量证据；
  * - fn/shape/array 参数位 Phase 1 不执法（§3.3 HOF 豁免：
  *   literalMeetsConstraint 对这些形态恒 false，直接查必 FP）。
@@ -1615,4 +1793,4 @@ type InjectedDomainEvidenceOpts = {
  */
 declare function checkInjectedDomainEvidence(fnName: string, source: string, records: InjectedDomainRecord[], opts: InjectedDomainEvidenceOpts): CheckIssue[];
 
-export { Abs, type AbsAssignRecord, type AbsCallRecord, type AbsFnImpl, type AbsInlay, AbsModuleExports, AstEnv, type CheckIssue, type CheckJson, type CheckOptions, type CheckReport, type ClassDef, Confidence, type ConstraintBuilder, type Diagnostic, type EffectiveInterface, type EffectiveInterfaceOpts, type Environment, type EvalOptions, type EvalResult, type FnAbs, type FnFp, type FormatOptions, type FunctionSignature, HofSite, type InjectedDomainRecord, type InterfaceDiag, type InterfaceSource, type LeakBudget, type LeqResult, type LiteralValue, 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, Ops, Phi, type PolyFn, Pred, PrimName, type RangeMeta, type RefineDiag, type RefineEntry, type RefineResolveOpts, type Refinement, RelSource, SELF, Shape, type SigImpl, type Slot, T, type TemplateMeta, type TemplatePartDesc, type TemplatePartView, type TemplatePredicateDecision, Term, type TypeParam, type TypeValue, absFunction, absTemplateViews, absToConstraint, absToTypeValue, add, allFixedTextOfViews, analyzeFn, applyAbsFn, applyBinaryOp, array, attachFnImpl, awaitAbs, boolean, buildArgsFromAssume, callAbsMethod, callFunction, canSkipLiteralCallScan, checkArg, checkCall, checkInjectedDomainEvidence, checkSource, classFromMethods, cmp, coerceAsyncReturn, collapseLiteralUnion, collectAbsInlays, collectAbsNodeTypes, concatString, concatTemplates, constraintToEntryAbs, createEnvironment, createRange, createTemplate, createTemplateAbs, currentPhi, decideEndsWith, decideIncludes, decideStartsWith, deepCloneTypeValue, defaultLeakBudget, defineClass, definitelyNotNullishShape, denoteGuard, describePhi, dispatchBinaryOp, dispatchMethod, dispatchProperty, div, effectiveInterface, emptyEnv, 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, formatAbs, formatAbsMultiline, formatCheckReport, formatConstraint, formatDiagnostics, formatShape, formatShapeSlot, formatTemplateNameViews, generalizeAll, generalizeFromAst, generalizeSourceKeyPart, generatedExportNames, getAbsProperty, getClass, getClassChain, getFnImpl, getFnNameAndBodies, getFnSig, getGeneralizeMemoSize, getParseSourceCacheSize, getPrimitiveTypeOf, getRangeMeta, getRefinedBase, getSlot, getTemplateParts, getTerm, getTvConfidence, hashSource, instanceOf, instantiateClass, instantiateConstraint, interfaceDiagCount, isFnSig, isIntFlag, isNodeModulesPath, isNudoConstraint, isNullishLitAbs, isObj, isRange, isSubtypeOf, isTemplate, isTemplateLike, joinAbs, joinFunctions, joinObjects, joinThenProject, joinValues, knownPrefixOfViews, knownSuffixOfViews, leakIfNeeded, lenTerm, leqAbs, listFunctionNames, literalMeetsConstraint, loadModuleDepsFingerprint, localNamedExports, lookupMethod, lookupMethodWithOwner, lookupSuperMethod, makeSum, matchRelIdentLit, maybeLeak, mergeAdjacentFixedViews, mergeObjectProperties, mock, mockHelperToTypeValue, mod, mul, narrowType, negAbs, normPath, notAbs, number, objOf, omit, parseSource, partial, pick, popPhi, projectBrand, pushPhi, refineAbsForRelTrue, refineDiagCount, refineToIndexedFull, relationFingerprint, relationFn, resetAbsCallBudget, resetCheckSourceMemo, resetFnFpCache, resetGeneralizeMemo, resetHashSourceCache, resetLeakCounter, resetNudoModuleExecCache, resetParseSourceCache, resetPhi, resolveDepPath, serializeCheckJson, setAbsAssignCollector, setAbsCallCollector, setAbsNodeCollector, setAbsTruncationCollector, setInterfaceDiagCollector, setRefineDiagCollector, setTvConfidence, shape, shapeOnlyFn, sidecarClosureFingerprint, sidecarPathOf, sidecarSpecsOf, simplifyUnion, spread, spy, stableAnalyzeKeySource, strictEqAbs, string, stripTypes, stub, sub, subtractType, superNameOf, takeInterfaceDiags, takeInterfaceDiagsSince, takeRefineDiags, takeRefineDiagsSince, templateMatchesValue, templatePartsOf, termDepth, termNodes, trueConstraint, typeValueEquals, typeValueToAbs, typeValueToString, typeofAbs, union, viewTemplateParts, widenLiteral, withPhiConstraint, withVar, wrapPromise };
+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, 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 };