@nudojs/core 1.2.2 → 1.4.0

package/dist/run-WJfj477N.d.ts

@@ -0,0 +1,769 @@
+import * as _babel_types from '@babel/types';
+import { Node, ImportDeclaration, File } from '@babel/types';
+
+/** 项（Term）：抽象值的身份。字面量是项的特例。 */
+type LiteralValue = string | number | boolean | bigint | null | undefined;
+type Term = {
+    op: "lit";
+    value: LiteralValue;
+} | {
+    op: "var";
+    id: string;
+} | {
+    op: "app";
+    fn: string;
+    args: Term[];
+};
+declare const lit: (value: LiteralValue) => Term;
+declare const v: (id: string) => Term;
+declare const app: (fn: string, args: Term[]) => Term;
+declare function termEquals(a: Term, b: Term): boolean;
+declare function termToString(t: Term): string;
+/** 常量折叠 + 简单代数化简 */
+declare function simplifyTerm(t: Term): Term;
+
+/** 约束（Pred）：附着在项上的事实，可传播。 */
+
+type PrimName = "number" | "string" | "boolean" | "bigint" | "symbol";
+/** JS `typeof` 完整结果域（8 标签）。Pred 的 typeof 节点用此域。 */
+type TypeofName = "undefined" | "object" | "boolean" | "number" | "bigint" | "string" | "symbol" | "function";
+/** typeof 标签全集（否定展开用；顺序稳定） */
+declare const TYPEOF_NAMES: readonly TypeofName[];
+/** abs prim 标签 → typeof 标签（恒等嵌入）。abs prim 仍是 PrimName 子集。 */
+declare function primToTypeof(p: PrimName): TypeofName;
+type Pred = {
+    op: "true";
+} | {
+    op: "false";
+} | {
+    op: "eq";
+    a: Term;
+    b: Term;
+} | {
+    op: "ne";
+    a: Term;
+    b: Term;
+} | {
+    op: "lt";
+    a: Term;
+    b: Term;
+} | {
+    op: "le";
+    a: Term;
+    b: Term;
+} | {
+    op: "gt";
+    a: Term;
+    b: Term;
+} | {
+    op: "ge";
+    a: Term;
+    b: Term;
+} | {
+    op: "and";
+    args: Pred[];
+} | {
+    op: "or";
+    args: Pred[];
+} | {
+    op: "not";
+    arg: Pred;
+} | {
+    op: "typeof";
+    t: Term;
+    type: TypeofName;
+}
+/**
+ * 显式有限证据：t 是有限数（非 NaN/±Inf）。
+ * 在场时允许线性环化简（x-x=0、k*(x+y) 分配等）；
+ * 默认关闭——无此谓词（或由 typeof=number + 双侧有限界自动导出）时
+ * 仍 fail-closed，与 BUG-001 / DEC-007A 口径一致。
+ */
+ | {
+    op: "assumeFinite";
+    t: Term;
+};
+declare const pTrue: Pred;
+declare const pFalse: Pred;
+declare const eq: (a: Term, b: Term) => Pred;
+declare const ne: (a: Term, b: Term) => Pred;
+declare const lt: (a: Term, b: Term) => Pred;
+declare const le: (a: Term, b: Term) => Pred;
+declare const gt: (a: Term, b: Term) => Pred;
+declare const ge: (a: Term, b: Term) => Pred;
+declare const ptypeof: (t: Term, type: TypeofName) => Pred;
+/** 显式有限证据：t 为有限数（非 NaN/±Inf），开启线性环化简 */
+declare const assumeFinite: (t: Term) => Pred;
+declare function and(...preds: Pred[]): Pred;
+declare function or(...preds: Pred[]): Pred;
+declare function not(p: Pred): Pred;
+/**
+ * 逻辑否定（De Morgan）：¬(A∧B)=¬A∨¬B；¬(A∨B)=¬A∧¬B；双重否定消去。
+ * typeof 否定展开为其余 TypeofName 标签的析取——8 标签域是 JS typeof 的
+ * 完整结果域，展开健全且相对完备。
+ *
+ * 关系比较（lt/le/gt/ge）的否定 **不是** 全序对偶：JS 里 NaN 参与时
+ * 全部关系为 false，故 ¬(x<5) 真而 x≥5 假。精确否定是 not(lt)；
+ * 正向全序事实（Φ ⊢ x≥5 ⇒ x<5 为假）仍由 totalOrderDual 处理。
+ * eq↔ne 是精确否定，不受 NaN 影响。
+ */
+declare function negatePred(p: Pred): Pred;
+declare function predEquals(a: Pred, b: Pred): boolean;
+declare function predToString(p: Pred): string;
+/** 把 pred 里的 Term 用 subst 替换（用于 bound 变量重命名等） */
+declare function substPred(p: Pred, subst: (t: Term) => Term): Pred;
+/** 收集 pred 中出现的自由变量 */
+declare function predVars(p: Pred): Set<string>;
+/** 约束环境 Φ：Pred 的合取 */
+type Phi = Pred;
+declare const emptyPhi: Phi;
+declare const phiAnd: typeof and;
+/**
+ * 外部蕴含 oracle（可选 SMT 等）。内建判定证不出时调用。
+ * 返回 true=可证；false/undefined=仍不可证（保持 fail-closed）。
+ * 默认无 oracle——纯内建区间/线性判定，不引入 solver 依赖。
+ */
+type ImplicationOracle = (phi: Phi, pred: Pred) => boolean | undefined;
+declare function setImplicationOracle(fn: ImplicationOracle | undefined): void;
+declare function getImplicationOracle(): ImplicationOracle | undefined;
+/** 简单蕴含：在区间/线性/字面量/typeof 可判定范围内判断 Φ ⊢ pred */
+declare function implies(phi: Phi, pred: Pred): boolean;
+/** 便捷：数字下界 */
+declare function gtNum(term: Term, n: number): Pred;
+declare function geNum(term: Term, n: number): Pred;
+declare function ltNum(term: Term, n: number): Pred;
+declare function leNum(term: Term, n: number): Pred;
+
+/** 抽象值 Abs = 形状 × 项 × 约束 × 置信度 */
+
+type Confidence = "exact" | "path" | "widened" | "mock" | "partial" | "opaque";
+type Shape = {
+    k: "never";
+}
+/**
+ * any：JS 里可以是任意值（无约束参数）。
+ * 运算按真实 JS 语义取并集，不是「分析失败」。
+ */
+ | {
+    k: "any";
+}
+/** unknown：分析拿不到信息（求值失败/泄漏），不是「任意值」 */
+ | {
+    k: "unknown";
+} | {
+    k: "prim";
+    type: PrimName;
+} | {
+    k: "obj";
+    slots: Record<string, {
+        value: Abs;
+        optional?: boolean;
+        readonly?: boolean;
+    }>;
+    index?: {
+        key: Abs;
+        value: Abs;
+    };
+    open?: boolean;
+} | {
+    k: "arr";
+    element: Abs;
+} | {
+    k: "tuple";
+    elements: Abs[];
+    rest?: Abs;
+    /** 已删除下标（delete a[i] / 字面量空洞）：读值为 undefined，`in` 判定 false */
+    holes?: number[];
+} | {
+    k: "fn";
+    params: string[];
+    name?: string;
+    paramTypes?: Abs[];
+    returnType?: Abs;
+    /**
+     * Dual-facet globals (Number/Array/…): callable AND carries static members.
+     * `$get` reads these before falling back to Function.prototype names.
+     */
+    slots?: Record<string, {
+        value: Abs;
+        optional?: boolean;
+        readonly?: boolean;
+    }>;
+} | {
+    k: "brand";
+    name: string;
+    shape: Abs;
+} | {
+    k: "eff";
+    eff: "promise" | "generator";
+    inner: Abs;
+} | {
+    k: "sum";
+    members: Abs[];
+};
+type Abs = {
+    shape: Shape;
+    term?: Term;
+    pred?: Pred;
+    conf: Confidence;
+    /**
+     * C2.4：分支 join 可解释标注（如 `join(number | string)`）。
+     * 仅展示用：不进 leq / 指纹 / check 等价；formatAbs 读取。
+     */
+    pathNote?: string;
+};
+declare const never: Abs;
+/** 分析无信息 */
+declare const unknown: Abs;
+/**
+ * 无约束 JS 值（未标注入口参数 / 显式 any()）。
+ * ≠ unknown：unknown 表示引擎推导失败，any 表示开发者未写契约。
+ */
+declare const anyAbs: Abs;
+/** 带 term 的 any（generalize type-var） */
+declare function anyVar(id: string, conf?: Confidence): Abs;
+declare function num(): Abs;
+declare function str(): Abs;
+declare function bool(): Abs;
+declare function numLit(value: number): Abs;
+declare function strLit(value: string): Abs;
+declare function boolLit(value: boolean): Abs;
+declare function bigintLit(value: bigint): Abs;
+/** 带项的符号数，例如参数 x */
+declare function numVar(id: string, pred?: Pred, conf?: Confidence): Abs;
+declare function obj(slots: Record<string, {
+    value: Abs;
+    optional?: boolean;
+}>): Abs;
+declare function confJoin(a: Confidence, b: Confidence): Confidence;
+declare function absToString(a: Abs): string;
+declare function shapeToString(s: Shape): string;
+/** 从 term 反推 prim shape */
+declare function shapeOfTerm(t: Term): Shape;
+/** 构造带项的结果 Abs；pred 相对 term */
+declare function abs(shape: Shape, term: Term | undefined, pred: Pred | undefined, conf: Confidence): Abs;
+declare function isNumPrim(a: Abs): boolean;
+declare function isStrPrim(a: Abs): boolean;
+declare function isBigPrim(a: Abs): boolean;
+/** 置信度：字面量全确定 */
+declare function isExactLit(a: Abs): boolean;
+/**
+ * tagged result：把「无字面量」与「字面量 undefined」分开。
+ * 判定是否是字面量必须看 `ok`，禁止用 `value !== undefined` / `(litValue(...).ok ? litValue(...).value : undefined) !== undefined`。
+ */
+type LitValueResult = {
+    ok: true;
+    value: LiteralValue;
+} | {
+    ok: false;
+};
+declare function litValue(a: Abs): LitValueResult;
+
+/**
+ * may-throw 效果收集（design-cli-semantics §3.3）。
+ * any/nullish 成员访问等危险操作记录 throws 域，不立刻 hard-fail 求值。
+ * Collector/tryFrames 经 AsyncLocalStorage 会话隔离，避免 LSP 并发串档。
+ */
+
+type MayThrowEffect = {
+    /** throws 类型名，如 TypeError */
+    kind: string;
+    /** 人类可读成因 */
+    cause: string;
+    /** 接收者展示：any / null / undefined / number… */
+    recv?: string;
+    /** 成员名 */
+    name?: string;
+    line?: number;
+    column?: number;
+};
+/** 隔离一次分析的 may-throw 收集（check / analyzer 入口包一层） */
+declare function runWithMayThrowSession<T>(body: () => T): T;
+declare function setMayThrowCollector(c: ((e: MayThrowEffect) => void) | null): void;
+declare function getMayThrowCollector(): ((e: MayThrowEffect) => void) | null;
+declare function pushMayThrowFrame(): void;
+/**
+ * 弹出 try 帧。discard=true（catch 消化）时返回空；否则返回帧内效果供上浮。
+ */
+declare function popMayThrowFrame(discard: boolean): MayThrowEffect[];
+/**
+ * 孤儿 soft 效果上浮：若仍有外层 try 帧则并入外层（nested try + outer catch）；
+ * 否则交给 collector。不得在栈非空时直接 flush，否则 outer catch 被旁路。
+ */
+declare function orphanMayThrowEffects(effects: MayThrowEffect[]): void;
+/** evaluator：try 开始时压 soft 帧 */
+declare function $tryMarkSoft(): void;
+/** evaluator catch 消化 try 内 soft may-throw */
+declare function $tryDigestSoft(): void;
+/** evaluator 无 handler / 出口 / rethrow：上浮未消化 soft may-throw（外层 try 可再消化） */
+declare function $tryReleaseSoft(): MayThrowEffect[];
+declare function flushMayThrowEffects(effects: MayThrowEffect[]): void;
+declare function recordMayThrow(e: MayThrowEffect): void;
+/** throws 类型名 → Abs（brand Error 形态，formatShape 打出名字） */
+declare function errorTypeAbs(name: string): Abs;
+/** 效果集 → throws Abs（never = 无 may-throw） */
+declare function mayThrowEffectsToAbs(effects: MayThrowEffect[]): Abs;
+/**
+ * throws Abs → 展示名（TypeError / TypeError | RangeError）。
+ * 非 brand/sum 时按 Abs 形状给出可运行时名，不再一律 "Error"。
+ */
+declare function formatThrowsAbs(t: Abs | undefined): string | undefined;
+/** JS Error 家族：`@nudo:throws Error` 覆盖全部子类（与 instanceof 语义一致） */
+declare const ERROR_FAMILY: Set<string>;
+/** throws Abs → kind 名列表（sum 拆臂；绝不把 `"A | B"` 当单个 kind） */
+declare function throwAbsToKinds(t: Abs | undefined): string[];
+/** declared/ignore 条目是否盖住 kind（`Error` 盖 Error 家族；`*` 由调用方先判） */
+declare function throwsKindCovered(kind: string, names: readonly string[]): boolean;
+/** effects 是否被 ignore 列表吞掉（kind 或 Error 族） */
+declare function isThrowsIgnored(kind: string, ignore: readonly string[] | undefined): boolean;
+/**
+ * L2 throws 过滤（口径固定）：
+ * 1. **declare 优先**（@nudo:throws / case !! throws / sidecar fn.throws）——有意 fail-fast；
+ * 2. ignoreThrows 其次——迁移期全类放行，**不是**声明的替代品。
+ */
+declare function filterGateThrows(effects: MayThrowEffect[], declared: readonly string[] | "*" | undefined, ignore: readonly string[] | undefined): MayThrowEffect[];
+/** effects 过滤后的剩余（L2 --ignore-throws） */
+declare function filterIgnoredThrows(effects: MayThrowEffect[], ignore: readonly string[] | undefined): MayThrowEffect[];
+/**
+ * 申报式抛错过滤（@nudo:throws / case !! throws / sidecar fn.throws）。
+ * `*` = 全部申报，L2 清空；数组 = kind 或 Error 族覆盖。
+ * 申报 ≠ ignoreThrows：前者是「这是有意 fail-fast」，后者是「迁移期先别管」。
+ */
+declare function filterDeclaredThrows(effects: MayThrowEffect[], declared: readonly string[] | "*" | undefined): MayThrowEffect[];
+
+/**
+ * 调用 Abs 一等函数（absFunction impl）或 mock apply。
+ * 供 求值引擎 import 绑定包装：`(...args) => $call(absFn, args)`。
+ *
+ * 统一顺序：apply → body → relation → isRelFn（委托 applyAbsFn）。
+ * 行为对齐说明（与旧 $call 的差异，均属刻意）：
+ * 1. 带 body 的函数也进 call-budget（递归会 truncated 而非爆栈）
+ * 2. body 抛错与 apply 同径 rethrow（不吞成 never 返回，调用边界决定吸收）
+ * 3. 无 impl 时 isRelFn 可走 E 路径（旧版恒 unknown）
+ */
+
+/** 清空 pure memo（宿主入口 / 会话缓存失效） */
+declare function clearPureMemo(): void;
+/**
+ * apply 返回的 throws 面 → 调用方控制流通道（H1 单点路由）。
+ * always-throw（abs=never）→ NudoThrow，由调用边界收成 throws；
+ * may-throw → pushThrowExit 记入调用方 throwExits（try/catch 可吸收）。
+ */
+declare function routeApplyThrows(r: Abs, throws: Abs | undefined): Abs;
+declare function $call(fn: Abs, args: Abs[], thisVal?: Abs): Abs;
+
+/**
+ * 求值引擎调用点记录：transpile 把 `f(args)` 改成 $callNamed，
+ * 分析时可收集 call@ 所需的 AbsCallRecord。
+ * 成员缺失诊断见 member-diag.ts（共用，避免循环依赖）。
+ */
+
+type EvalCallRecord = {
+    fnName: string;
+    args: Abs[];
+    result: Abs;
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    threw?: boolean;
+};
+/** 清空 pureCallMemo（宿主入口 / 会话缓存失效） */
+declare function clearPureCallMemo(): void;
+/** B 赋值记录（与 ast-records.ts AbsAssignRecord 同形；structuralAssignIssues 消费） */
+type EvalAbsAssignRecord = {
+    name: string;
+    prev: Abs | undefined;
+    next: Abs;
+    line?: number;
+    column?: number;
+    conditional?: boolean;
+};
+/** 返回先前 collector，便于嵌套调用 save/restore（禁止 finally 置 null 砸外层） */
+declare function setEvalAssignCollector(collector: ((r: EvalAbsAssignRecord) => void) | null): ((r: EvalAbsAssignRecord) => void) | null;
+/** 结构赋值记录（transpile 插桩调用；无收集器时 no-op） */
+declare function $assignRecord(name: string, prev: Abs | undefined, next: Abs, line: number, column: number, conditional: boolean): void;
+declare function setEvalBindingSink(sink: Map<string, unknown> | null): void;
+/** 顶层绑定记录（transpile 插桩调用） */
+declare function $recordBinding(name: string, value: unknown): void;
+/** 返回先前 collector，便于嵌套调用 save/restore（禁止 finally 置 null 砸外层） */
+/** 成员/方法调用点打点（$invoke 等；无收集器时 no-op）。不进 $callNamed 预算。 */
+declare function noteEvalCallRecord(r: EvalCallRecord): void;
+declare function setEvalCallCollector(collector: ((r: EvalCallRecord) => void) | null): ((r: EvalCallRecord) => void) | null;
+declare function getEvalCallCollector(): ((r: EvalCallRecord) => void) | null;
+/**
+ * 按名调用并记录。
+ * loc: [line, column]（1-based line，0-based column，与 Babel 一致）
+ * argLocs: 与 args 对齐的实参字面量源位置（provenance；无 loc 用 null）
+ */
+declare const MAX_EVAL_CALL_DEPTH = 64;
+/** 总调用上限：与 call-budget.MAX_TOTAL_CALLS 同阀（递归×循环×分支展开的
+ *  规模阀）。200k 在病态展开（lodash _baseFlatten）下 ~30s，20k 收口到
+ *  ~3s——截断 → opaque（更保守，zero-FP 安全）。 */
+declare const MAX_EVAL_TOTAL_CALLS = 20000;
+/** 宿主入口前强制清零（测试 / 显式 API）。执行入口请用 enterEvalCallBudgetSession。 */
+declare function resetEvalCallBudget(): void;
+/** @nudo:budget：在 run 期间抬高 B 路径 depth/calls 上限；finally 恢复 */
+declare function withEvalBudgetOverride(budget: {
+    depth?: number;
+    calls?: number;
+}, run: () => void): void;
+/**
+ * 进入执行会话。最外层才重置预算；嵌套（导出桥 $call → apply →
+ * callTranspiledExportFull）必须继承外层深度/cycle 键/totalCalls，否则
+ * 外层帧被抹掉，$callNamed 的 evalExitCall 再把 depth 打成负数。
+ */
+declare function enterEvalCallBudgetSession(): void;
+/** 退出执行会话。禁止把 sessionDepth 留在负数。 */
+declare function exitEvalCallBudgetSession(): void;
+/** 预算快照（测试/诊断：断言嵌套期间 depth/keys 不被清空、depth 不为负） */
+declare function getEvalCallBudgetState(): {
+    depth: number;
+    totalCalls: number;
+    activeKeys: number;
+    sessionDepth: number;
+};
+declare function $callNamed(name: string, fn: unknown, args: Abs[], loc?: [number, number], argLocs?: Array<[number, number] | null | undefined>): Abs;
+
+/**
+ * 共享纯类型结点（AstEnv / HofCollectCtx / HofSite / RelSource）。
+ *
+ * 这些类型曾形成 ast-env ↔ hof ↔ abs-fn 的类型环（ast-env 引 HofCollectCtx，
+ * hof/abs-fn 引 AstEnv）。抽到本叶模块（只依赖 abs/term/babel，不回指
+ * ast-env/hof/abs-fn）后，三个消费方都从这里取类型，环即断。
+ *
+ * 稳定导入路径不变：ast-env.ts 重导出 AstEnv，hof.ts 重导出 HOF 三类型。
+ */
+
+/**
+ * 关系来源标记：P4 豁免与 diagnostics 依赖它，禁止隐式猜。
+ * - promote：使用驱动提升（generalize symbolic / instantiate 局部）
+ * - refine：@nudo:contract 契约
+ * - relationFn：harvest/mock/测试直接写入 fnRels 时的预留来源（P4 error 路径）
+ */
+type RelSource = "promote" | "refine" | "relationFn";
+type HofSite = {
+    /** 形参名（函数形参） */
+    param: string;
+    /** 输入侧 term：实参的 term（element 的 var/lit/app）；map 1 个、reduce 2 个 */
+    argTerms: Term[];
+    /** 输出侧：归纳出的返回 Abs */
+    result: Abs;
+    /** 源位置，便于 diagnostics */
+    loc?: {
+        line: number;
+        column: number;
+    };
+};
+/**
+ * run 局部 collector（与 Phi 并列，不进 Φ 合并）。
+ * symbolic 一次跑：安装并沉淀到 PolyFn；instantiate 重跑：装 throwaway
+ * 副本——形状提升仍生效，结果不写回共享状态（见 generalize.ts run()）。
+ */
+type HofCollectCtx = {
+    /** 本次归纳的形参名集合（身份判定用） */
+    paramNames: ReadonlySet<string>;
+    /** 本次 typeParams 的 α id 集合（term 复用白名单） */
+    alphaIds: Set<string>;
+    /** fresh α 计数 */
+    freshSeq: {
+        n: number;
+    };
+    sites: HofSite[];
+    fnRels: Map<string, {
+        abs: Abs;
+        source: RelSource;
+    }>;
+    entryShapes: Map<string, {
+        abs: Abs;
+        source: RelSource;
+    }>;
+};
+type AstEnv = {
+    vars: Map<string, Abs>;
+    /** 用户函数：name → { params, body } */
+    fns: Map<string, {
+        params: string[];
+        body: Node;
+        async?: boolean;
+        kind?: string;
+    }>;
+    /** class 表（旁路，withVar 必须保留） */
+    classes?: Map<string, unknown>;
+    /** 当前正在求值的方法所属类名（super.x() 从它的父类派发） */
+    currentOwner?: string;
+    /** P2：generalize symbolic 跑的 HOF collector（run 局部，不进 Φ） */
+    hofCollect?: HofCollectCtx;
+};
+
+/**
+ * Abs 上的一等函数：shape 是 fn，实现在旁路（不污染 Shape）。
+ * 与 term-registry 同一纪律：不给共享单例挂 impl。
+ */
+
+/** Abs 原生 env/builtin 实现（evaluator 优先） */
+type AbsSigImpl = (args: Abs[], thisVal?: Abs) => Abs | undefined;
+/**
+ * 已知不抛的 apply 返回面（裸 Abs，无 throws 通道）。
+ * 等价 `Abs`，仅作意图标注：impl 作者写死「本 apply 不抛」时用它收窄签名，
+ * 调用侧仍应经 `absOnly` / `isAbsApplyResult` 取 abs（`AbsFnImpl.apply` 静态面是宽的）。
+ */
+type AbsApplyNoThrow = Abs;
+/**
+ * 已知不抛的 apply 实现签名（`AbsSigImpl` 的 apply 对偶）。
+ * 返回裸 `Abs` = 不抛；需要 throws 面时改用 `AbsFnImpl["apply"]`（`AbsApplyReturn`）。
+ */
+type AbsApplyNoThrowFn = (args: Abs[], thisVal?: Abs) => AbsApplyNoThrow;
+/**
+ * apply 契约返回的 throws 通道（H1 / DESIGN-003）。
+ * `throws` 必填：不抛传 `never`。$call 统一路由——
+ * always-throw（abs=never）→ NudoThrow 由调用边界收成 throws；
+ * may-throw → pushThrowExit 记入调用方 throwExits（try/catch 可吸收）。
+ * 包装 `callTranspiledExportFull` 必须走 `callTranspiledExportApply`，
+ * 不得手拆 `.result`（会静默丢 throws 面）。
+ *
+ * 构造只经 `makeAbsApplyResult`（打上 brand）；`isAbsApplyResult` 只认 brand，
+ * 避免裸对象靠 `!shape` 误判成 apply 结果、吞掉 throws 面。
+ */
+type AbsApplyResult = {
+    abs: Abs;
+    throws: Abs;
+    /** Discriminator stamped by makeAbsApplyResult. */
+    readonly applyResult: true;
+};
+/** apply 可返回裸 Abs（无 throws）或带 throws 通道的 AbsApplyResult */
+type AbsApplyReturn = Abs | AbsApplyResult;
+/** 唯一构造入口：打上 applyResult brand。 */
+declare function makeAbsApplyResult(abs: Abs, throws: Abs): AbsApplyResult;
+/** AbsApplyResult 判别：只认 brand（不靠 !shape 结构猜）。 */
+declare function isAbsApplyResult(v: AbsApplyReturn): v is AbsApplyResult;
+/**
+ * apply 返回值取 abs 面（已知不抛 / 测试面只想看结果时用）。
+ * 丢弃 throws 通道——若 impl 可能抛，必须走 `$call` 统一路由，不得用本函数吞 throws。
+ */
+declare function absOnly(r: AbsApplyReturn): AbsApplyNoThrow;
+type AbsFnImpl = {
+    params: string[];
+    /** 可选：无 body 时走 relation（纯关系 fn） */
+    body?: Node;
+    async?: boolean;
+    /** 声明时捕获的环境（闭包） */
+    env?: AstEnv;
+    kind?: string;
+    /**
+     * 调用时直接派发（mock withArgs 等），优先于 body。
+     * 返回裸 Abs = 不抛；返回 AbsApplyResult 时 throws 面经 $call 统一路由，
+     * 不得在 apply 内自行 re-throw / pushThrowExit（会与 $call 路由叠算）。
+     */
+    apply?: (args: Abs[], thisVal?: Abs) => AbsApplyReturn;
+    /**
+     * 对象方法（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
+     * build mocks should stamp a stable fingerprint here.
+     * relation-only 必填（未传时 relationFn 自动生成）。
+     */
+    fingerprint?: string;
+    /** 无 body 时，按 paramTypes 做 α 替换得到返回 */
+    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">, opts?: {
+    name?: string;
+    paramTypes?: Abs[];
+    returnType?: Abs;
+    slots?: Record<string, {
+        value: Abs;
+        optional?: boolean;
+        readonly?: boolean;
+    }>;
+    conf?: Confidence;
+}): Abs;
+/** relationFn 稳定 fingerprint（同签名共享，见 §3.3 已知限制） */
+declare function relationFingerprint(paramTypes: Abs[], returnType: Abs): string;
+/**
+ * 无 body、纯关系的 fn Abs。params 仅记 arity。
+ *
+ * **双写纪律：** 同一份关系数据必须同时写到——
+ *   1. `shape.paramTypes` / `shape.returnType`  —— format / leq / 展示读这里
+ *   2. `impl.relation`                         —— D 路径应用读这里
+ * 两槽共享同一数组/对象引用（防内容分叉）；构造后请勿原地 mutate。
+ *
+ * 默认 conf="path"（与提升产物一致）。禁止静默对齐 absFunction 的 "exact"。
+ * fingerprint 必填（call-budget）；未传时由 paramTypes+returnType 稳定序列化生成。
+ * 同签名 relationFn 共享 fingerprint → 共享 budget 键（见 design §3.3 已知限制）。
+ */
+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?: {
+    params?: string[];
+    conf?: Confidence;
+}): Abs;
+
+/**
+ * Abs 模块面（无 fs）：import 绑定 + export 收集。
+ * 解析路径/读文件在 host；core 只吃「specifier → 导出表」。
+ */
+
+type AbsModuleExports = {
+    named: Record<string, Abs>;
+    default?: Abs;
+    /**
+     * 导出表来自成功求值（evalExportsToModuleExports）。
+     * fail-closed 空表 / harvest stub / env 手写表不设——missing-export 只对
+     * 成功求值的表报（zero-FP，避免与 module-missing 叠报）。
+     */
+    evaluated?: boolean;
+};
+/**
+ * 命名空间 Abs（`import * as ns` / `export * as ns` / CJS require 绑定）：
+ * open + path——导出收集可能不全（CJS 收集失败等），缺失成员是分析
+ * 视图不完整，不得按「运行时缺失」判定（不可调用判定会假抛 TypeError）。
+ * 单一构造点：bindImports / run.ts namespaceAbsOf / abs-modules-graph 同口径。
+ */
+declare function namespaceAbsOf(mod: AbsModuleExports): Abs;
+/** 把 import 说明符绑定进 env（宿主已求值依赖） */
+declare function bindImports(node: ImportDeclaration, env: AstEnv, modules: Record<string, AbsModuleExports>): void;
+/**
+ * 从已求值 env + AST 收集 ESM 导出。
+ * 支持：export function/const、export { a, b as c }、export default（具名）、
+ * 以及带 source 的 re-export（`export { a } from "mod"` / `export * from "mod"` /
+ * `export * as ns from "mod"`——需 host 传入已求值 modules）。
+ */
+declare function collectAbsExports(file: File, env: AstEnv, modules?: Record<string, AbsModuleExports>): AbsModuleExports;
+
+type RunTranspiledOptions = {
+    /** 说明符 → 依赖导出（host 模块图或 runTranspiled 产物） */
+    modules?: Record<string, AbsModuleExports | Record<string, unknown>>;
+    maxLoopIters?: number;
+    /** analyze = 跳过效应性顶层语句 */
+    mode?: "exec" | "analyze";
+    /** @nudo:replace 注入值：varName → Abs */
+    replacements?: Record<string, Abs>;
+    /** @nudo:replace 匹配表：传给 transpile */
+    replacementTargets?: Array<{
+        target: string;
+        varName: string;
+        stmtStart?: number;
+        stmtEnd?: number;
+    }>;
+    /** @nudo:as 注入值：varName → Abs */
+    asOverrides?: Record<string, Abs>;
+    /** @nudo:as 语句范围表 */
+    asOverrideTargets?: Array<{
+        varName: string;
+        stmtStart: number;
+        stmtEnd: number;
+    }>;
+    /** @nudo:env 全局 Abs（JSON/Math/console…）→ 作用域绑定 */
+    envGlobals?: Record<string, Abs>;
+    /** @nudo:mock 注入值：name → Abs（mockDirectivesToAbsSeeds 产物） */
+    mocks?: Record<string, Abs>;
+    /** 宽松全局（调用点发现 exec 采集：未声明全局调用保守 unknown 不中断） */
+    lenientGlobals?: boolean;
+};
+/**
+ * inject/modules **内容**指纹（memo 键）。对象身份对「每次新建同内容」
+ * 的 CLI 注入不稳——同一语义的 inject 跨 checkSource 调用会 miss 缓存。
+ */
+declare function runTranspiledOptionsMemoKey(opts: RunTranspiledOptions | undefined): string;
+declare const RUNTIME_IMPORT_RE: RegExp;
+declare function bindingsOf(run: Record<string, unknown>): Map<string, unknown> | undefined;
+/**
+ * 执行一段 求值引擎程序，返回顶层 `export function` / `export const`。
+ */
+declare function runTranspiled(source: string, opts?: RunTranspiledOptions): Record<string, unknown>;
+/** evaluator 回落事件（观测单一埋点；reason: unsupported:* = 能力边界，internal = 引擎自身缺陷） */
+type EvalFallback = {
+    reason: string;
+    message: string;
+    loc?: {
+        line: number;
+        column: number;
+    };
+};
+declare function setEvalFallbackCollector(collector: ((f: EvalFallback) => void) | null): void;
+/** 表达式级求值（scan 的 case 字面量实参等静态求值面）：编译单表达式经
+ *  eval 运行时执行。bindings：表达式自由标识符 → Abs（调用方按绑定表注入）。
+ *  编译失败抛错（调用方按需 catch）。 */
+declare function evalExprAbs(expr: _babel_types.Expression, bindings?: Record<string, Abs>): Abs;
+/** 回落计数（D6-A：internal 可暴露为 health 指标，不静默吞） */
+type EvalFallbackStats = {
+    internal: number;
+    unsupported: number;
+    moduleThrow: number;
+    total: number;
+};
+/** 始终累计（与 collector 无关）——health / 测试读同一口径 */
+declare function getEvalFallbackStats(): EvalFallbackStats;
+/** 宿主入口 / health 按文件分析前重置 */
+declare function resetEvalFallbackStats(): void;
+/** 记录一次 B 回落（body-fn / tryRunTranspiled / call 边界兜底共用） */
+declare function noteEvalFallback(e: unknown): void;
+/**
+ * B 单一入口：runTranspiled + 类型化回落观测。
+ * unsupported:*（能力边界）/ internal（B 缺陷）都记录到收集器；
+ * 返回 undefined 表示调用方应走解释路径。
+ */
+declare function tryRunTranspiled(source: string, opts?: RunTranspiledOptions): Record<string, unknown> | undefined;
+type TranspiledCallResult = {
+    result: Abs;
+    /** 非 never 表示函数可能 throw 该类型 */
+    throws: Abs;
+};
+/** 调用 runTranspiled 导出（捕获 $throw）。opts.phi：入口 Φ 种子
+ *  （instantiate/symbolic 的约束入口——eval 侧路径条件收窄）。
+ *  嵌套进入（导出桥 apply）继承外层预算；仅最外层宿主入口重置。 */
+declare function callTranspiledExportFull(exports: Record<string, unknown>, name: string, args: Abs[], opts?: {
+    phi?: Phi;
+}): TranspiledCallResult;
+/** 调用 runTranspiled 导出（仅结果） */
+declare function callTranspiledExport(exports: Record<string, unknown>, name: string, args: Abs[]): Abs;
+/**
+ * 包装 runTranspiled 导出为 Abs apply 钩子——throws 面经返回值通道强制保留
+ * （H1 / DESIGN-003）。这是包装 `callTranspiledExportFull` 的**唯一入口**：
+ * 返回 AbsApplyResult（`{abs, throws}`），$call 统一路由 throws。
+ * 手拆 `.result` 会静默丢 throws 面（BUG-006 根因）。
+ *
+ * `exports` 可传惰性 getter（互递归模块桥：导出表在桥创建后才赋值）。
+ */
+declare function callTranspiledExportApply(exports: Record<string, unknown> | (() => Record<string, unknown>), name: string): (args: Abs[], thisVal?: Abs) => AbsApplyResult;
+
+export { $tryDigestSoft as $, type Abs as A, runWithMayThrowSession as B, type Confidence as C, setMayThrowCollector as D, ERROR_FAMILY as E, throwAbsToKinds as F, throwsKindCovered as G, withEvalBudgetOverride as H, type HofCollectCtx as I, type HofSite as J, type AbsModuleExports as K, type LiteralValue as L, type MayThrowEffect as M, type RunTranspiledOptions as N, $assignRecord as O, type PrimName as P, $call as Q, type RelSource as R, type Shape as S, type Term as T, $callNamed as U, $recordBinding as V, type AbsApplyNoThrow as W, type AbsApplyNoThrowFn as X, type AbsApplyResult as Y, type AbsApplyReturn as Z, type AbsFnImpl as _, type Pred as a, num as a$, type AbsSigImpl as a0, type EvalAbsAssignRecord as a1, type EvalCallRecord as a2, type EvalFallback as a3, type ImplicationOracle as a4, type LitValueResult as a5, MAX_EVAL_CALL_DEPTH as a6, MAX_EVAL_TOTAL_CALLS as a7, RUNTIME_IMPORT_RE as a8, TYPEOF_NAMES as a9, geNum as aA, getEvalCallCollector as aB, getFnImpl as aC, getImplicationOracle as aD, gt as aE, gtNum as aF, implies as aG, isAbsApplyResult as aH, isBigPrim as aI, isExactLit as aJ, isNumPrim as aK, isStrPrim as aL, le as aM, leNum as aN, lit as aO, litValue as aP, lt as aQ, ltNum as aR, makeAbsApplyResult as aS, markPureFn as aT, namespaceAbsOf as aU, ne as aV, negatePred as aW, never as aX, not as aY, noteEvalCallRecord as aZ, noteEvalFallback as a_, type TranspiledCallResult as aa, type TypeofName as ab, abs as ac, absFunction as ad, absOnly as ae, absToString as af, and as ag, anyAbs as ah, anyVar as ai, app as aj, assumeFinite as ak, attachFnImpl as al, bigintLit as am, bindImports as an, bindingsOf as ao, bool as ap, boolLit as aq, callTranspiledExport as ar, callTranspiledExportApply as as, callTranspiledExportFull as at, collectAbsExports as au, confJoin as av, emptyPhi as aw, eq as ax, evalExprAbs as ay, ge as az, type Phi as b, numLit as b0, numVar as b1, obj as b2, or as b3, pFalse as b4, pTrue as b5, phiAnd as b6, predEquals as b7, predToString as b8, predVars as b9, primToTypeof as ba, ptypeof as bb, pureFnNameOf as bc, relationFingerprint as bd, relationFn as be, resetEvalCallBudget as bf, runTranspiled as bg, runTranspiledOptionsMemoKey as bh, setEvalAssignCollector as bi, setEvalBindingSink as bj, setEvalCallCollector as bk, setEvalFallbackCollector as bl, setImplicationOracle as bm, shapeOfTerm as bn, shapeOnlyFn as bo, shapeToString as bp, simplifyTerm as bq, str as br, strLit as bs, substPred as bt, termEquals as bu, termToString as bv, tryRunTranspiled as bw, unknown as bx, v as by, routeApplyThrows as bz, type AstEnv as c, $tryMarkSoft as d, $tryReleaseSoft as e, type EvalFallbackStats as f, clearPureCallMemo as g, clearPureMemo as h, enterEvalCallBudgetSession as i, errorTypeAbs as j, exitEvalCallBudgetSession as k, filterDeclaredThrows as l, filterGateThrows as m, filterIgnoredThrows as n, flushMayThrowEffects as o, formatThrowsAbs as p, getEvalCallBudgetState as q, getEvalFallbackStats as r, getMayThrowCollector as s, isThrowsIgnored as t, mayThrowEffectsToAbs as u, orphanMayThrowEffects as v, popMayThrowFrame as w, pushMayThrowFrame as x, recordMayThrow as y, resetEvalFallbackStats as z };