@nudojs/core 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -1,195 +1,59 @@
-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';
+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-tAeoYvzY.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-tAeoYvzY.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-AtnAfY9U.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 andC, M as any, O as array, P as boolean, Q as checkArg, T as checkCall, U as constraintToEntryAbs, V as effectiveInterface, W as execNudoModule, X as extractDeclaredThrows, Y as extractNudoImports, Z as extractRefineReturnFromSource, _ as extractRefinesFromSource, $ as fn, a0 as fnConstraintToEntryReqs, a1 as formatCheckReport, a2 as formatConstraint, a3 as formatDiagnostics, a4 as formatEffectiveInterfaceDisplay, a5 as formatGithubAnnotations, a6 as formatGitlabCodeQuality, a7 as formatInterfaceTierLine, a8 as generatedExportNames, a9 as getParseSourceCacheSize, aa as getTerm, ab as instantiateConstraint, ac as interfaceDiagCount, ad as interfaceSourceOf, ae as interfaceTierOf, af as isIntFlag, ag as isNodeModulesPath, ah as isNudoConstraint, ai as lenTerm, aj as litC, ak as localNamedExports, al as number, am as omit, an as partial, ao as pick, ap as refineDiagCount, aq as refineToIndexedFull, ar as resetNudoModuleExecCache, as as resetParseSourceCache, at as serializeCheckJson, au as serializeCheckJsonMulti, av as setInterfaceDiagCollector, aw as setRefineDiagCollector, ax as shape, ay as sidecarClosureFingerprint, az as sidecarPathOf, aA as string, aB as takeInterfaceDiags, aC as takeInterfaceDiagsSince, aD as takeRefineDiags, aE as takeRefineDiagsSince, aF as throwConstraintToKinds, aG as union } from './check-report-AtnAfY9U.js';
+import { A as AbsModuleExports, R as RunTranspiledOptions } from './index-B7Lb8FU6.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-B7Lb8FU6.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;
-    fork(): Environment;
-    has(name: string): boolean;
-    snapshot(): Environment;
-    getOwnBindings(): Record<string, TypeValue>;
-};
-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。
+ * AstEnv：抽象求值环境类型面（ast-eval 删除后保留）。
+ * 类型定义在 hof-types.ts（打破 ast-env ↔ hof ↔ abs-fn 类型环）；
+ * 本文件保留空环境 / withVar 的便捷构造并重导出 AstEnv 供稳定路径导入。
+ * 仍被 B 路径 check / leq / generalize / builtins 消费。
  */
-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;
+/** 空求值环境（分析宿主用：不带任何绑定） */
+declare function emptyEnv(): AstEnv;
+declare function withVar(env: AstEnv, name: string, value: Abs): AstEnv;
 
-type RangeMeta = {
-    min?: number;
-    max?: number;
-    /** 下界开区间：value > min（JS 实数，不能写成 >= min+1） */
-    minExclusive?: boolean;
-    /** 上界开区间：value < max */
-    maxExclusive?: boolean;
-    integer?: boolean;
+type 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, Abs>;
 };
-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 +61,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 +79,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（便于链式使用）。
@@ -229,13 +93,6 @@ declare function mockHelperToTypeValue(helper: MockHelper, env: Environment): Ty
  */
 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;
-
 /**
  * 路径约束栈（Φ）。
  *
@@ -256,6 +113,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） */
@@ -265,7 +124,13 @@ 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 仍是用户可见形参
+     * （不含 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
@@ -277,10 +142,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 已知限制） */
@@ -301,6 +183,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?: {
@@ -308,6 +196,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。
@@ -364,6 +393,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;
 /** 一元负号：字面量折叠；符号数翻转不等式 */
@@ -372,83 +419,242 @@ 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 库。
- * 覆盖 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 evalRegExpCtor / $regex 共用） */
+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 的 new Error 路径共用——catch 形参成员访问可解。
+ */
+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) 共用，避免环。
+ */
+
+declare function symbolIdOf(a: Abs): number | undefined;
+declare function symbolDescriptionAbs(a: Abs): Abs | undefined;
+declare function isSymbolAbs$1(a: Abs | undefined): boolean;
+
+/**
+ * Symbol 构造 / 描述 / 字符串化
+ */
+
+/**
+ * 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;
+
+/**
+ * Object.prototype 成员（hasOwnProperty / isPrototypeOf / toString / …）
  */
 
-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;
 /**
- * 若项超预算，替换为新鲜变量，并返回附加等式 pred：fresh = originalTerm。
- * 未超预算则原样返回。
+ * Object.prototype 方法语义（B-path $invoke 与 Object.prototype.X.call 共用）。
+ * null-proto 接收者无这些方法——返回 undefined（调用方走 TypeError 路径）。
+ * 返回 undefined = 未接管。
  */
-declare function maybeLeak(a: Abs, budget?: LeakBudget, label?: string): Abs;
+declare function evalObjectProtoMethod(name: string, thisVal: Abs, args: Abs[]): Abs | undefined;
+/** Object.prototype.X 一等函数（bindThis：call/apply 把 receiver 注入首参） */
+declare function objectProtoMethodAbs(name: string): Abs;
+
 /**
- * 批量：在算术结果上应用 leak。
+ * Abs 方法表：模板字符串 / 结构值上的方法与属性。
+ * 类型即计算——方法结果仍是 Abs，可继续参与约束推理。
+ * 宿主 TypeValue 的 dispatchMethod 只服务 IR 兜底，不是真理源。
+ * 模板语义（前缀/后缀/固定文本/长度/谓词判定）统一在 template.ts。
  */
-declare function leakIfNeeded(a: Abs, budget?: LeakBudget, label?: string): Abs;
+
+/**
+ * 调用 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、函数重载并。
@@ -460,6 +666,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>;
@@ -498,9 +706,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";
@@ -519,6 +728,99 @@ 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）。
+ * 按 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 污染。
+ *  惰性：无集合写入时不分配 WeakMap（fork 热路径上无 Map/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 | null>): void;
+declare function beginCollectionFork(): void;
+declare function noteCollectionWrite(id: object): 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 可变语义） */
+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）。
@@ -540,33 +842,20 @@ type LeqResult = {
  * src 可赋给 tgt。
  * phi：路径前提（可选）；env：用于 brand 继承链。
  */
+/** Required arity from fn param labels — skips rest (`...`) and optional (`?`). */
+declare function requiredFnArity(params: readonly string[] | undefined): number;
 declare function leqAbs(src: Abs, tgt: Abs, opts?: {
     phi?: Phi;
     env?: AstEnv;
 }): LeqResult;
 
 /**
- * Babel AST 抽象求值：把「类型即计算」接到真实 JS 源码。
- * 支持表达式、函数声明/箭头、return、if、const/let、块作用域、类、循环。
+ * Abs 域记录类型面（ast-eval 执行器删除后保留）。
+ * 运行时记录由 B 通道（BCallRecord/$assignRecord）产生；此处的类型是
+ * checkSource drift / 结构赋值诊断的共享形状，仍被 check.ts 等消费。
  */
 
-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>;
-};
-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[];
@@ -577,9 +866,7 @@ type AbsCallRecord = {
     };
     threw?: boolean;
 };
-declare function setAbsCallCollector(collector: ((r: AbsCallRecord) => void) | null): void;
-declare function setAbsNodeCollector(collector: ((node: Node, value: Abs) => void) | null): void;
-/** 赋值记录：结构可赋值检查用 */
+/** Abs 域赋值记录（B 通道 $assignRecord 的同形投影） */
 type AbsAssignRecord = {
     name: string;
     prev?: Abs;
@@ -589,98 +876,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;
-    /**
-     * if 无 else 且 consequent 已 return/throw：真分支已产出 value，
-     * 假分支 fall-through 仍可能走后续语句。evalBlock 需与后续结果 join。
-     */
-    partialReturn?: boolean;
-};
-/**
- * 分析一段 JS 源码。
- * 若含多个顶层函数声明，先注册全部，再对 `main` 或最后一个有调用的函数求值。
- * 更简单：提供 `analyzeFunction(source, fnName, args)`。
- */
-declare function evalSource(source: string, entry: {
-    fn: string;
-    args: Abs[];
-}, opts?: EvalOptions): EvalResult;
-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;
-/**
- * 程序级 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 友好的字符串。
@@ -701,366 +896,81 @@ declare function formatShape(a: Abs): string;
 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 ∧ …
+ * C4.1：函数形参表面（contract surface）——
+ * 侧车 `fn({…})` / `@nudo:contract` 参数名与求值形参的对齐基线。
  *
- * 在 *.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;
+ * - 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[];
     /**
-     * 界平移：term 平移 n 后重写常数界（x>0 ⇒ x+n>n）。
-     * 仅数值标量界链合法；length 界 / shape / array / union / fn → throw。
+     * 契约名 → 对象属性键。rename `{a: b}` 时契约可写 a 或 b，
+     * 投影必须用属性键 a（Abs 对象只有 slot a）。
      */
-    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;
-/** array(item) —— 数组，元素满足 item */
-declare function array(item: NudoConstraint | ConstraintBuilder): ConstraintBuilder;
-/**
- * object 形状约束（契约规范形状，无需 interface）：
- *
- *   shape({ id: number().gt(0), name: string() })
- */
-declare function shape(fields: Record<string, NudoConstraint | ConstraintBuilder>): ConstraintBuilder;
-/** union(...cs)：成员析取；instantiate 为 or(...)，entry Abs 为成员 joinAbs。空参 throw */
-declare function union(...cs: (NudoConstraint | ConstraintBuilder)[]): ConstraintBuilder;
-/**
- * fn(params, returns?, { throws? })：一等函数约束。
- * Phase 1 只展示不执法：参数位 instantiate 恒真（pTrue），
- * 逐参约束经 fnConstraintToEntryReqs 消费。
- */
-declare function fn(params: Record<string, NudoConstraint | ConstraintBuilder>, returns?: NudoConstraint | ConstraintBuilder, opts?: {
-    throws?: NudoConstraint | ConstraintBuilder;
-}): 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;
+    propKey: Record<string, string>;
+    /** 仅嵌套内出现、顶层不可单独表达的名（降级用） */
+    nested: string[];
+    index: number;
 };
-declare function resetNudoModuleExecCache(): void;
-/**
- * 解析 `ms delay` / `n percent` → [param, Pred]
- * 多条用 && 或换行连接。
- * 同时保留原始 NudoConstraint（shape 字段检查用）。
- */
-type RefineEntry = {
-    param: string;
-    pred: Pred;
-    constraint: NudoConstraint;
+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 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;
+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;
 
 /**
- * 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";
-/**
- * 源文件本地 named export 表：收集本文件声明并导出的名字——
- * `export function/const/let/var/class` 声明形式，以及本地列表
- * `export { x }` / `export { local as exported }`（按**导出名**绑定，
- * 与侧车同名自动绑定口径一致）。
- * 排除 re-export（`export {x} from` / `export *`）与 `export default`。
- */
-declare function localNamedExports(source: string): Set<string>;
-/**
- * 侧车源码的生成段导出名：导出名所在声明的**前置注释块**含 `@generated`
- * 标记（emit 产物 canonical 注释为 `@generated by nudo`）→ 该名为 generated。
- * Phase 1 简化：只看紧邻声明上方的注释块（与 extractRefineLines 同款反向
- * 行扫描，空行可跨）；隔了代码行 / 无标记 / 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 由调用方处理）。
+ * Abs 键 / α-rename（从 generalize.ts 拆出的纯结构变换）。
  */
-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;
 
-type LoadDepsFingerprint = {
-    fp: string;
-    paths: string[];
-    /** 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;
+/** 公开：收集 Abs 自由 term 变元（dts 泛型投影 / α 作用域判定复用 L2 基建）。 */
+declare function collectAbsFreeVars(a: Abs): Set<string>;
 
 declare function resetGeneralizeMemo(): void;
 declare function getGeneralizeMemoSize(): number;
@@ -1069,6 +979,7 @@ declare function getGeneralizeMemoSize(): number;
  * 返回删除的条目数。路径需与 generalize 时 resolveDepPath 形态一致（建议先 norm）。
  */
 declare function evictGeneralizeMemoForPaths(paths: string[]): number;
+
 type TypeParam = {
     id: string;
     value: Abs;
@@ -1080,11 +991,16 @@ type PolyFn = {
     instantiate: (args: Abs[], phi?: Phi) => Abs;
     symbolic: Abs;
     display: string;
-    /** 入口契约（@nudo:refine），供签名/inlay 展示 */
+    /** 入口契约（@nudo:contract），供签名/inlay 展示 */
     entryReqs?: Array<{
         param: string;
         pred: Pred;
     }>;
+    /**
+     * 形参表面（C4.1）：默认/rest/解构的契约可绑定名。
+     * 与 params（求值展示名）并列；检查/侧车匹配走 formals。
+     */
+    formals?: FormalParam[];
     /**
      * 函数形参的符号外延（与 typeParams 同 α 空间）。
      * symbolic 一次跑正常结束时从 env 快照拷出；instantiate 重跑不写。
@@ -1107,11 +1023,12 @@ 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;
     label?: string;
-    /** 传入则把 @nudo:refine 挂到入口 param Abs */
+    /** 传入则把 @nudo:contract 挂到入口 param Abs */
     refine?: EffectiveInterfaceOpts;
     /** 预解析 AST，避免 check 批量场景重复 parse */
     file?: ReturnType<typeof parseSource>;
@@ -1119,318 +1036,99 @@ 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 + 约束。
+ * 列出源码中的顶层函数名。
+ * 与 scan.listTopFunctions 对齐：解 export default / export const 箭头与函数表达式。
+ * （不 import scan：scan 依赖本文件，避免环。完整 CJS/class 面用 listTopFunctions。）
  */
-declare function checkCall(source: string, fnName: string, args: Abs[], phi?: Phi): Diagnostic[];
-declare function formatDiagnostics(diags: Diagnostic[]): string;
-
+declare function listFunctionNames(source: string): string[];
 /**
- * Template string 拼接（代数侧）。
- * 表示：prim(string) + refinement.meta.templateParts = Abs[]
- * 与 core 的 createTemplate 对齐，使 `"x" + string + "!"` 得到 template refined。
- *
- * 本模块是模板语义的唯一真理源：前缀/后缀/固定文本/长度/匹配/名称渲染/
- * 相邻合并/谓词判定等纯计算以「中性 part 视图」（TemplatePartView）暴露；
- * TypeValue 侧（refinements/template.ts）与 Abs 方法表（methods.ts）只做薄适配。
+ * 按 assume 集合构造实参：被 assume 的参数给带约束的符号，其余 any
+ * （design-cli-semantics §2：入口无约束 = any，不是 unknown）。
  */
-
-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;
-/** 三值判定；两侧分别把 "unknown" 适配为 boolPrim（Abs）或 undefined（TypeValue） */
-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;
+declare function buildArgsFromAssume(source: string, fnName: string, assumeIds: Set<string>): Abs[];
 
 /**
- * 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).
+ * CheckOptions — 从 check.ts 拆出的纯类型，打断 check ↔ check-memo/may-throw 环。
+ * 实现不得 import check.ts；check.ts re-export 本类型以保持公共面。
  */
-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).
+ * check 选项：core 不碰 fs；host 用 loadModule 喂 require 目标源码。
  */
-
-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;
+type CheckOptions = {
+    /** 相对/绝对 require 说明符 → 模块源码；undefined = 解析失败 */
+    loadModule?: (spec: string, fromFile: string) => string | undefined;
+    /** 当前文件路径（供 loadModule 解析相对 spec） */
+    fromFile?: string;
+    /**
+     * 侧车 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>;
 };
-/** 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;
-/**
- * 无 refine、无模块语法、无兄弟调用、无任何调用表达式 → scanLiteralCalls 可整段跳过。
- * 必须保守：`const x = f(-1)` / `if (f(-1))` / `require("x")` 都含 CallExpression，
- * 只认顶层 ExpressionStatement 会漏报约束违规。
- */
-declare function canSkipLiteralCallScan(source: string, file: File): boolean;
 
 /**
- * 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 目标源码。
- */
-type CheckOptions = {
-    /** 相对/绝对 require 说明符 → 模块源码；undefined = 解析失败 */
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    /** 当前文件路径（供 loadModule 解析相对 spec） */
-    fromFile?: string;
-    /**
-     * 侧车 ambient 绑定开关（host 从 package.json#nudo.interface.autoBind
-     * 解析后下传；默认 true）。false = check/LSP 执法路径不自动加载侧车
-     * （§2.2「整体关闭」承诺覆盖 CI 门禁，不只是打印路径）。
-     */
-    autoBind?: boolean;
-};
 /**
  * 检查一个文件：
  * - 每个顶层函数 generalize；无法得到任何签名 → warning
@@ -1461,63 +1159,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` 反推前置条件（那是控制流，不是对外契约）。
- */
-type AbsInlay = {
-    /** 1-based 行号 */
-    line: number;
-    /** 0-based 列（label 插入点） */
-    character: number;
-    label: string;
-    kind: "type" | "parameter";
-};
-/**
- * 收集源码中函数签名的 Abs inlay：
- * - 参数后：仅 `@nudo:refine` 声明的前置契约
- * - `{` 前：返回计算形（`x | x * 2`），无 term 时退回 shape
- */
-declare function collectAbsInlays(source: string, refineOpts?: {
-    loadModule?: (spec: string, fromFile: string) => string | undefined;
-    fromFile?: string;
-}): AbsInlay[];
-
-/**
- * 指称：Abs → 运行时谓词（设计 §2.7）。
- * - 无 pred：按 shape 检查（typeof / 结构）
- * - 有 pred：在 `term ↦ v` 下检查可判定的数值比较
- * - sum：任一成员
- */
-
-/** 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 分层推导的生成侧半边）。
  *
@@ -1539,8 +1180,8 @@ declare function typeValueToAbs(tv: TypeValue): Abs;
  * 嵌套 or/not）→ undefined。bigint/symbol、tuple、fn、eff、brand、
  * any（无 or-pred）、never、unknown → undefined。
  *
- * 注意：本模块从 "./constraint.ts" 直接路径 import（桶导出消歧为
- * term.ts 的 lit / pred.ts 的 and，见 constraint.ts 头注释）。
+ * 注意：约束构建器从 "./constraint.ts" 导入（litC/andC 与 term/pred 的
+ * lit/and 已消歧；侧车注入键名仍为 lit/and）。
  */
 
 /** Abs → 契约；不可表达 → undefined */
@@ -1556,63 +1197,4 @@ declare function absToConstraint(a: Abs): NudoConstraint | undefined;
  */
 declare function joinThenProject(absList: Abs[]): NudoConstraint | undefined;
 
-/**
- * 源码级调用图侦察：从 check 门禁拆出的 AST 扫描层。
- *
- * 职责：不做代数求值结论，只回答「谁在调用谁、实参长什么样」——
- * - listTopFunctions：顶层函数清单
- * - collectCallResolvers / resolveCalleeFn / collectForwarders：别名 / 对象属性 /
- *   require / 动态 import / 无条件转发 的调用解析
- * - scanLiteralCalls：字面量调用点实参 vs 前置约束的违例收集
- */
-
-/**
- * 注入记录的最小结构面（service CallRecord 的成员子集——core 不反向依赖
- * service 的 CallRecord 声明，按结构兼容接收）。
- */
-type InjectedDomainRecord = {
-    argTypes: TypeValue[];
-    resultType: TypeValue;
-    throws: TypeValue;
-};
-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 形态
- *   无法归因到确定值，不参与（widened/partial conf 经 absToTypeValue 投影
- *   为非 literal 形态，天然被此条排除；getTvConfidence 再兜一道底）；
- * - 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 十项，无截断标记）——递归截断走
- *   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, 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, 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 };