@nudojs/core 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,17 +1,25 @@
-import { Node } from '@babel/types';
+import { Node, File, ImportDeclaration, Expression } from '@babel/types';
 
 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 | null | undefined;
+type LiteralValue$1 = 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>;
@@ -22,7 +30,7 @@ type Refinement = {
 };
 type TypeValue = {
     kind: "literal";
-    value: LiteralValue;
+    value: LiteralValue$1;
 } | {
     kind: "primitive";
     type: "number" | "string" | "boolean" | "bigint" | "symbol";
@@ -62,7 +70,7 @@ type TypeValue = {
 };
 declare function createUnion(...members: TypeValue[]): TypeValue;
 declare const T: {
-    readonly literal: (value: LiteralValue) => TypeValue;
+    readonly literal: (value: LiteralValue$1) => TypeValue;
     readonly number: TypeValue;
     readonly string: TypeValue;
     readonly boolean: TypeValue;
@@ -80,10 +88,21 @@ declare const T: {
     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 & {
@@ -96,32 +115,46 @@ declare function narrowType(tv: TypeValue, predicate: (member: TypeValue) => boo
 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 sub: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly mul: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly div: (left: TypeValue, right: TypeValue) => TypeValue;
-    readonly mod: (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 typeof_: (operand: TypeValue) => TypeValue;
     readonly not: (operand: TypeValue) => TypeValue;
-    readonly neg: (operand: TypeValue) => TypeValue;
 };
 declare function applyBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
 declare function dispatchBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
 declare function dispatchMethod(receiver: TypeValue, name: string, args: TypeValue[]): TypeValue | undefined;
 declare function dispatchProperty(receiver: TypeValue, name: string): TypeValue | undefined;
 
+/**
+ * 模板字面量谓词，独立于 template.ts 以断开运行时循环引用：
+ * type-value.ts（联合吸收律）与 template.ts 都依赖本模块，而本模块对
+ * type-value.ts 只有 `import type` 边（编译后消失），运行时依赖保持单向
+ * type-value.ts / template.ts -> template-predicates.ts。
+ */
+declare function isTemplate(tv: TypeValue): boolean;
+
 declare function getKnownPrefix(parts: TypeValue[]): string;
 declare function getKnownSuffix(parts: TypeValue[]): string;
 declare function createTemplate(parts: TypeValue[]): TypeValue;
-declare function isTemplate(tv: TypeValue): boolean;
+
 declare function getTemplateParts(tv: TypeValue): TypeValue[] | undefined;
 declare function concatTemplates(left: TypeValue, right: TypeValue): TypeValue;
 
@@ -134,4 +167,1560 @@ declare function createRange(meta: RangeMeta): TypeValue;
 declare function isRange(tv: TypeValue): boolean;
 declare function getRangeMeta(tv: TypeValue): RangeMeta | undefined;
 
-export { type Environment, type LiteralValue, Ops, type RangeMeta, type Refinement, T, type TypeValue, applyBinaryOp, concatTemplates, createEnvironment, createRange, createTemplate, deepCloneTypeValue, dispatchBinaryOp, dispatchMethod, dispatchProperty, getKnownPrefix, getKnownSuffix, getPrimitiveTypeOf, getRangeMeta, getRefinedBase, getTemplateParts, isRange, isSubtypeOf, isTemplate, mergeObjectProperties, narrowType, simplifyUnion, subtractType, typeValueEquals, typeValueToString, widenLiteral };
+/**
+ * Nudo Mock 帮助函数
+ *
+ * 提供类型安全的 mock 创建，替代 sinon 表达式
+ */
+
+type MockHelper = {
+    kind: "mock-helper";
+    returnValue?: TypeValue;
+    resolvedValue?: TypeValue;
+    rejectedValue?: TypeValue;
+    implementation?: (...args: TypeValue[]) => TypeValue;
+    onFirstCallValue?: TypeValue;
+    onSecondCallValue?: TypeValue;
+    withArgsCases?: {
+        args: TypeValue[];
+        returnValue: TypeValue;
+    }[];
+    callsFakeImpl?: TypeValue;
+};
+/**
+ * 创建一个 stub mock
+ * 用法: @nudo:mock fetch = stub()
+ */
+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;
+}
+/**
+ * 创建一个 spy mock
+ * 用法: @nudo:mock handler = spy()
+ */
+declare function spy(): MockHelper;
+declare namespace spy {
+    var returns: (value: TypeValue) => MockHelper;
+}
+/**
+ * 创建一个 mock
+ * 用法: @nudo:mock service = mock()
+ */
+declare function mock(): MockHelper;
+/**
+ * 将 MockHelper 转换为 TypeValue
+ */
+declare function mockHelperToTypeValue(helper: MockHelper, env: Environment): TypeValue;
+
+/**
+ * 原地剥除 AST 中的 TS-only 语法节点/字段，返回同一棵 AST（便于链式使用）。
+ * 不改写任何 loc/start/end；语句删除只影响所在数组，不重排兄弟节点。
+ */
+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;
+}): File;
+
+/** 项（Term）：抽象值的身份。字面量是项的特例。 */
+type LiteralValue = string | number | boolean | 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";
+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: PrimName;
+};
+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: PrimName) => Pred;
+declare function and(...preds: Pred[]): Pred;
+declare function or(...preds: Pred[]): Pred;
+declare function not(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;
+/** 简单蕴含：在区间/字面量可判定范围内判断 Φ ⊢ 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;
+
+/**
+ * 路径约束栈（Φ）。
+ *
+ * Φ 是当前控制流路径上的合取前提。代数运算（add/cmp/…）读取它做单调传播；
+ * evaluator 在 if 守卫处 push/pop。栈属于类型系统，不属于 host CLI。
+ */
+
+declare function currentPhi(): Phi;
+declare function pushPhi(p: Phi): void;
+declare function popPhi(): void;
+declare function resetPhi(): void;
+/** 在当前 Φ 上合取额外约束，body 结束后恢复 */
+declare function withPhiConstraint(extra: Phi, body: () => void): void;
+declare function describePhi(): string;
+
+/** 抽象值 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;
+} | {
+    k: "fn";
+    params: string[];
+    name?: string;
+    paramTypes?: Abs[];
+    returnType?: Abs;
+} | {
+    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;
+};
+declare const never: Abs;
+/** 分析无信息 */
+declare const unknown: 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;
+/** 带项的符号数，例如参数 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 isExactLit(a: Abs): boolean;
+declare function litValue(a: Abs): LiteralValue | undefined;
+
+/**
+ * 项（Term）防爆炸：深度/宽度阈值 → leak 为新鲜 var + 等式约束。
+ */
+
+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。
+ * 未超预算则原样返回。
+ */
+declare function maybeLeak(a: Abs, budget?: LeakBudget, label?: string): Abs;
+/**
+ * 批量：在算术结果上应用 leak。
+ */
+declare function leakIfNeeded(a: Abs, budget?: LeakBudget, label?: string): Abs;
+
+/**
+ * Abs 模块面（无 fs）：import 绑定 + export 收集。
+ * 解析路径/读文件在 host；core 只吃「specifier → 导出表」。
+ */
+
+type AbsModuleExports = {
+    named: Record<string, Abs>;
+    default?: 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"`——
+ * 需 host 传入已求值 modules）。
+ */
+declare function collectAbsExports(file: File, env: AstEnv, modules?: Record<string, AbsModuleExports>): AbsModuleExports;
+
+/**
+ * Babel AST 抽象求值：把「类型即计算」接到真实 JS 源码。
+ * 支持表达式、函数声明/箭头、return、if、const/let、块作用域、类、循环。
+ */
+
+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;
+};
+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） */
+type AbsCallRecord = {
+    fnName: string;
+    args: Abs[];
+    result: Abs;
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    threw?: boolean;
+};
+declare function setAbsCallCollector(collector: ((r: AbsCallRecord) => void) | null): void;
+declare function setAbsNodeCollector(collector: ((node: Node, value: Abs) => void) | null): void;
+/** 赋值记录：结构可赋值检查用 */
+type AbsAssignRecord = {
+    name: string;
+    prev?: Abs;
+    next: Abs;
+    line?: number;
+    column?: number;
+};
+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;
+};
+/**
+ * 分析一段 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;
+/**
+ * 从源码分析指定函数在给定实参下的抽象结果。
+ *
+ * @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 上的一等函数：shape 是 fn，实现在旁路（不污染 Shape）。
+ * 与 term-registry 同一纪律：不给共享单例挂 impl。
+ */
+
+type AbsFnImpl = {
+    params: string[];
+    body: Node;
+    async?: boolean;
+    /** 声明时捕获的环境（闭包） */
+    env?: AstEnv;
+    kind?: string;
+    /** 调用时直接派发（mock withArgs 等），优先于 body */
+    apply?: (args: Abs[]) => Abs;
+    /**
+     * 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.
+     */
+    fingerprint?: string;
+};
+declare function attachFnImpl(a: Abs, impl: AbsFnImpl): void;
+declare function getFnImpl(a: Abs): AbsFnImpl | undefined;
+/** 造一个带实现的 Abs 函数值 */
+declare function absFunction(params: string[], impl: Omit<AbsFnImpl, "params">): Abs;
+
+/**
+ * 算术核：单调性 + 常量折叠 + 约束传播。
+ * 这是「类型即计算」的主武器——x>0 时 x+1 必须得到 >1。
+ */
+
+/**
+ * 抽象加法：eval(a + b) —— 跟真实 JS，不无根据地假定 number。
+ * 1. 双方字面量 → 直接求值
+ * 2. 双方 number prim → term + 单调性 pred，shape=number
+ * 3. 含 string/template → 拼接
+ * 4. any / type-var 参与 → 按 JS + 的可能结果取并集：number | string
+ *    （bool/null 走 ToNumber→number；object 默认 ToPrimitive→string；
+ *      bigint/symbol 边角不在默认并集里，由调用点实例化再收窄）
+ *    无契约的 score(x){return x+1}：score("x") 合法，不得钉成 number。
+ */
+declare function add(a: Abs, b: Abs, phi?: Phi): Abs;
+type NumBounds = {
+    lo?: {
+        value: number;
+        strict: boolean;
+    };
+    hi?: {
+        value: number;
+        strict: boolean;
+    };
+};
+/**
+ * 提取 Abs 上相对 term 的数值界。
+ * 优先用自身 pred；否则查 Φ（针对 var id）。
+ */
+declare function numericBounds(a: Abs, phi?: Phi): NumBounds | undefined;
+/** 减法：a - b = a + (-b)，数值上做单调性 */
+declare function sub(a: Abs, b: Abs, phi?: Phi): Abs;
+/** 乘法：字面量直接求值；×正数同向缩放；×负数翻转不等式；×0 归零 */
+declare function mul(a: Abs, b: Abs, phi?: Phi): Abs;
+/**
+ * 除法：字面量折叠；除以正/负常数时按单调性推界。
+ * 除以 0：JS 语义为 ±Infinity / NaN，shape 仍 number（不报违例）。
+ */
+declare function div(a: Abs, b: Abs, phi?: Phi): Abs;
+/**
+ * 取模：字面量折叠；`x % k`（k>0 字面量）结果界在 (−|k|, |k|)。
+ * 整数模可收紧到 [0, k)，此处先做保守实数界。
+ */
+declare function mod(a: Abs, b: Abs, phi?: Phi): Abs;
+/** 比较：返回 boolean Abs；若双字面量则 exact */
+declare function cmp(op: "lt" | "le" | "gt" | "ge" | "eq" | "ne", a: Abs, b: Abs, phi?: Phi): Abs;
+/** 从比较结果 Abs 提取「若为真」的额外约束（供 if 使用） */
+declare function trueConstraint(c: Abs): Pred | undefined;
+declare function falseConstraint(c: Abs): Pred | undefined;
+
+/**
+ * 语言表面运算（仍在 Abs 上）：typeof / 一元- / ! / nullish 相等。
+ * 类型即计算——一元与控制流判定与二元算术同一运算域。
+ */
+
+/** JS typeof：结果域永远是 string */
+declare function typeofAbs(a: Abs): Abs;
+/** 一元负号：字面量折叠；符号数翻转不等式 */
+declare function negAbs(a: Abs, _phi?: Phi): Abs;
+/** 逻辑非 */
+declare function notAbs(a: Abs): Abs;
+/** 该 shape 在 JS 上一定不是 null/undefined */
+declare function definitelyNotNullishShape(s: Shape): boolean;
+declare function isNullishLitAbs(a: Abs): boolean;
+/**
+ * 严格相等（Abs）：双字面量折叠；nullish 与 definitely-not-nullish → false。
+ * 返回 undefined = 无法判定（交给 boolean + 调用方）。
+ */
+declare function strictEqAbs(a: Abs, b: Abs): boolean | undefined;
+
+/**
+ * Abs 侧常用 builtin：shape 级运算，不依赖 TypeValue host 库。
+ * 覆盖 Math / Object / JSON / Number / 全局转换函数的常见面。
+ */
+
+/** Math.* — 字面量可折叠的返回精确值，否则 number */
+declare function evalMathMethod(name: string, args: Abs[]): Abs | undefined;
+/** Object.keys/values/entries/assign */
+declare function evalObjectMethod(name: string, args: Abs[]): Abs | undefined;
+/** JSON.parse / stringify */
+declare function evalJsonMethod(name: string, args: Abs[]): Abs | undefined;
+/** Number.isInteger / isNaN / parseFloat 等 */
+declare function evalNumberStatic(name: string, args: Abs[]): Abs | undefined;
+/** 全局 parseInt / parseFloat / isNaN / Number / String / Boolean */
+declare function evalGlobalFn(name: string, args: Abs[]): Abs | undefined;
+/** Array.isArray / Array.from / Array.of */
+declare function evalArrayStatic(name: string, args: Abs[]): Abs | undefined;
+/** new Date() / Date.now / date.getTime */
+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;
+declare function evalPromiseStatic(name: string, args: Abs[]): Abs | undefined;
+/** 命名空间分派入口 */
+declare function evalNamespaceCall(ns: string, method: string, args: Abs[]): Abs | undefined;
+/** 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 兜底，不是真理源。
+ */
+
+/**
+ * 调用 Abs 方法。返回 undefined = 未接管（调用方走其它路径）。
+ */
+declare function callAbsMethod(recv: Abs, name: string, args: Abs[]): Abs | undefined;
+/** 属性读取：template.length 等 */
+declare function getAbsProperty(recv: Abs, name: string): Abs | undefined;
+
+/**
+ * 结构层：对象槽位、spread、函数重载并。
+ * 纪律：积之和默认；optional 塌缩是显式损失；函数并保输入→输出相关性。
+ */
+
+type Slot = {
+    value: Abs;
+    optional?: boolean;
+    readonly?: boolean;
+};
+type ObjShape = {
+    k: "obj";
+    slots: Record<string, Slot>;
+    index?: {
+        key: Abs;
+        value: Abs;
+    };
+    open?: boolean;
+};
+declare function objOf(slots: Record<string, Slot>, opts?: {
+    index?: {
+        key: Abs;
+        value: Abs;
+    };
+    open?: boolean;
+}): Abs;
+declare function isObj(a: Abs): a is Abs & {
+    shape: ObjShape;
+};
+/**
+ * spread：base ⊕ over（右侧覆盖，不是 join）
+ * 未出现在 over 的 key 保留 base；over 的 key 覆盖。
+ */
+declare function spread(base: Abs, over: Abs): Abs;
+/**
+ * 对象 join：默认积之和（sum），不自动折 optional。
+ * 同 key 集：槽位级 join（字面量并）；异 key 集：保持 sum。
+ */
+declare function joinObjects(a: Abs, b: Abs): Abs;
+/** 值级 join：字面量保留为… Phase A 对 prim 做 term 保留策略 */
+declare function joinValues(a: Abs, b: Abs): Abs;
+declare function makeSum(a: Abs, b: Abs): Abs;
+/**
+ * 显式损失：sum-of-products → optional 槽（仅 emit/阈值）。
+ * 强制 #widened。
+ */
+declare function collapseToOptional(sum: Abs): Abs;
+type FnAbs = Abs & {
+    shape: {
+        k: "fn";
+        params: string[];
+        name?: string;
+        /** 外延参数类型（若已知） */
+        paramTypes?: Abs[];
+        /** 外延返回类型 */
+        returnType?: Abs;
+    };
+};
+declare function fnOf(params: string[], name?: string): Abs;
+/**
+ * 函数 join：签名并（重载），禁止 (A|C)→(B|D)。
+ */
+declare function joinFunctions(a: Abs, b: Abs): Abs;
+/** 通用 join：分派到对象/函数/值 */
+declare function joinAbs(a: Abs, b: Abs): Abs;
+
+/**
+ * 结构可赋值：src ≤ tgt（Abs 上的 leq）。
+ *
+ * 规则与 TS 结构子类型同构，但作用在推断出的 Abs 上：
+ * - 对象宽度 + 深度；optional 可缺
+ * - brand 名义；fn 参数逆变、返回协变
+ * - pred：src 蕴含 tgt（更严的值可赋给更宽的目标）
+ *
+ * 不是完备 checker 的替代——是 Abs 之间的兼容判定。
+ */
+
+type LeqResult = {
+    ok: boolean;
+    /** Nudo 式原因（actual ⊭ target），不是 TS 文案 */
+    reason?: string;
+};
+/**
+ * src 可赋给 tgt。
+ * phi：路径前提（可选）；env：用于 brand 继承链。
+ */
+declare function leqAbs(src: Abs, tgt: Abs, opts?: {
+    phi?: Phi;
+    env?: AstEnv;
+}): LeqResult;
+
+/**
+ * 格式化：把 Abs 渲染成人类可读 / CLI 友好的字符串。
+ */
+
+type FormatOptions = {
+    /** 是否显示 term= */
+    showTerm?: boolean;
+    /** 是否显示 pred */
+    showPred?: boolean;
+    indent?: string;
+};
+declare function formatAbs(a: Abs, opts?: FormatOptions): string;
+declare function formatShape(a: Abs): string;
+/** 多行展示，CLI 用 */
+declare function formatAbsMultiline(a: Abs, label?: string): string;
+
+/**
+ * 约束模板构建器（参数无关）。
+ *
+ *   number().gt(0)                    → 占位项 self 上的 Pred
+ *   number().int().ge(0)              → 整数 + 下界
+ *   string().min(1)                   → 非空串（长度）
+ *   array(number().gt(0))             → 元素约束
+ *   shape({ id: number().gt(0) })     → object 形状约束
+ *   instantiate("ms")                 → Pred ms > 0 / u.id > 0 ∧ …
+ *
+ * 在 *.nudo.js 里执行；不是 zod 绑定，是我们自己的运行时 API。
+ * 不需要 interface/type 语法——契约用 JS 表达式声明。
+ */
+
+/** 模板占位项；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;
+};
+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;
+    /** 字段可选（仅在 shape 内有意义） */
+    optional(): ConstraintBuilder;
+};
+/** 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;
+/** 把模板绑定到参数名：self → paramName；shape 展开为字段访问 Pred */
+declare function instantiateConstraint(c: NudoConstraint, paramName: string): Pred;
+/**
+ * 契约 → 函数入口 param Abs（infer/hover 用）。
+ * 标量：prim + pred；shape：obj slots 递归。
+ */
+declare function constraintToEntryAbs(c: NudoConstraint, paramName: string): Abs;
+
+/**
+ * 精化契约解析：唯一形态
+ *
+ *   @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:import { delay, percent } from "./delay.nudo.js"` */
+type NamedImport = {
+    names: string[];
+    spec: string;
+};
+declare function extractNudoImports(source: string): NamedImport[];
+/**
+ * 执行 *.nudo.js（真实 JS + 我们的构建器）。
+ * 把 export const 改写成 const，末尾 return { names }。
+ */
+declare function execNudoModule(src: string): Record<string, unknown>;
+type RefineResolveOpts = {
+    loadModule?: (spec: string, fromFile: string) => string | undefined;
+    fromFile?: string;
+};
+declare function resetNudoModuleExecCache(): void;
+/**
+ * 解析 `ms delay` / `n percent` → [param, Pred]
+ * 多条用 && 或换行连接。
+ * 同时保留原始 NudoConstraint（shape 字段检查用）。
+ */
+type RefineEntry = {
+    param: string;
+    pred: Pred;
+    constraint: NudoConstraint;
+};
+declare function extractRefinesFromSource(source: string, fnName: string, opts?: RefineResolveOpts): RefineEntry[];
+/** refine 参数 → 带约束模板的下标表（shape 检查用） */
+declare function refineToIndexedFull(source: string, fnName: string, paramNames: string[], opts?: RefineResolveOpts): Array<[number, RefineEntry]>;
+/**
+ * 解析 `@nudo:refine return positive` → 返回精化。
+ * 返回 undefined = 无声明（不猜后置）。
+ */
+declare function extractRefineReturnFromSource(source: string, fnName: string, opts?: RefineResolveOpts): {
+    name: string;
+    constraint: NudoConstraint;
+} | undefined;
+
+type LoadDepsFingerprint = {
+    fp: string;
+    paths: string[];
+    /** BFS 撞到节点上限：剩余 dep 未进指纹，键不可信 */
+    truncated: boolean;
+};
+declare function normPath(p: string): string;
+/** core 不引 path：相对 spec 纯字符串拼接（与 LSP resolve 对齐时双方 norm） */
+declare function resolveDepPath(fromFile: string, spec: string): string;
+/**
+ * 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[];
+/**
+ * Fingerprint every loadModule-reachable dep (not only `*.nudo.js`), including
+ * one hop of transitive specs from each dep source.
+ */
+declare function loadModuleDepsFingerprint(source: string, loadModule: (spec: string, fromFile: string) => string | undefined, fromFile: string): LoadDepsFingerprint;
+
+declare function resetGeneralizeMemo(): void;
+declare function getGeneralizeMemoSize(): number;
+/**
+ * LSP/宿主：`*.nudo.js` 变更后按路径定向逐出依赖它的 L0 条目。
+ * 返回删除的条目数。路径需与 generalize 时 resolveDepPath 形态一致（建议先 norm）。
+ */
+declare function evictGeneralizeMemoForPaths(paths: string[]): number;
+type TypeParam = {
+    id: string;
+    value: Abs;
+};
+type PolyFn = {
+    name: string;
+    params: string[];
+    typeParams: TypeParam[];
+    instantiate: (args: Abs[], phi?: Phi) => Abs;
+    symbolic: Abs;
+    display: string;
+    /** 入口契约（@nudo:refine），供签名/inlay 展示 */
+    entryReqs?: Array<{
+        param: string;
+        pred: Pred;
+    }>;
+};
+declare function generalizeFromAst(fnName: string, source: string, opts?: {
+    budget?: LeakBudget;
+    label?: string;
+    /** 传入则把 @nudo:refine 挂到入口 param Abs */
+    refine?: RefineResolveOpts;
+    /** 预解析 AST，避免 check 批量场景重复 parse */
+    file?: ReturnType<typeof parseSource>;
+    /** 预计算 load-deps 指纹（checkSource 整文件一次，避免 per-fn 重读） */
+    depsFp?: LoadDepsFingerprint;
+}): PolyFn | undefined;
+declare function generalizeAll(source: string, opts?: {
+    budget?: LeakBudget;
+}): PolyFn[];
+/** 列出源码中的顶层函数名 */
+declare function listFunctionNames(source: string): string[];
+/**
+ * 按 assume 集合构造实参：被 assume 的参数给带约束的符号，其余 unknown。
+ */
+declare function buildArgsFromAssume(source: string, fnName: string, assumeIds: Set<string>): Abs[];
+
+/**
+ * 约束诊断：检查调用点实参是否满足函数的前置约束 / 参数 shape。
+ * 输出可行动的建议，而不是 TS 式「类型不匹配」。
+ */
+
+type Diagnostic = {
+    severity: "error" | "warning" | "info";
+    code: string;
+    message: string;
+    suggestion?: string;
+    fn?: string;
+    argIndex?: number;
+};
+/**
+ * 检查实参是否满足「期望约束」。
+ * expect: 相对参数 term 的 pred，例如 term > 0
+ * arg: 实际实参 Abs
+ */
+declare function checkArg(arg: Abs, expect: Pred | undefined, phi?: Phi): Diagnostic | undefined;
+/**
+ * 对一次函数调用做诊断：实参 shape + 约束。
+ */
+declare function checkCall(source: string, fnName: string, args: Abs[], phi?: Phi): Diagnostic[];
+declare function formatDiagnostics(diags: Diagnostic[]): string;
+
+/**
+ * Template string 拼接（代数侧）。
+ * 表示：prim(string) + refinement.meta.templateParts = Abs[]
+ * 与 core 的 createTemplate 对齐，使 `"x" + string + "!"` 得到 template refined。
+ */
+
+type TemplateMeta = {
+    templateParts: Abs[];
+};
+/** 从 Abs 提取 template parts（已是 template 则展开，否则 [self]） */
+declare function templatePartsOf(a: Abs): Abs[];
+/**
+ * 构造 template Abs。
+ * - 全字面量 → exact lit
+ * - 单 string prim → prim
+ * - 否则 prim(string) + pred(name=template, meta.templateParts)
+ */
+declare function createTemplateAbs(parts: Abs[]): Abs;
+declare function isTemplateLike(a: Abs): boolean;
+/** 字符串拼接：字面量折叠 + template parts 合并 */
+declare function concatString(a: Abs, b: Abs): Abs;
+
+/**
+ * 语言覆盖：class / new / instanceof / this / async await。
+ * brand 表示名义类；eff("promise") 表示异步效应。
+ *
+ * 方法体：ClassDef.methods 存 AST body，调用时在 this=receiver 下求值。
+ */
+
+type MethodDef = {
+    name: string;
+    params: string[];
+    body: Node;
+    kind?: string;
+    async?: boolean;
+};
+type ClassDef = {
+    name: string;
+    instanceShape: Abs;
+    ctorParams: string[];
+    methods: Map<string, MethodDef>;
+    superClass?: string;
+};
+declare function defineClass(env: AstEnv, def: ClassDef): void;
+declare function getClass(env: AstEnv, name: string): ClassDef | undefined;
+/** 沿继承链找类 */
+declare function getClassChain(env: AstEnv, name: string): ClassDef[];
+/** new C(...) → brand 实例；并跑 constructor 以写入字段 */
+declare function instantiateClass(env: AstEnv, className: string, args: Abs[], evalBody?: (fn: {
+    params: string[];
+    body: Node;
+}, args: Abs[], thisVal: Abs, env: AstEnv) => Abs): Abs;
+/** 读取当前 this 所属类的父类名 */
+declare function superNameOf(env: AstEnv, className: string): string | undefined;
+/**
+ * instanceof：沿继承链匹配 brand 名。
+ */
+declare function instanceOf(left: Abs, rightClassName: string, env?: AstEnv): Abs;
+declare function projectBrand(self: Abs, key: string): Abs;
+/** 在 brand 上查找方法定义（含继承） */
+declare function lookupMethod(env: AstEnv, receiver: Abs, methodName: string): MethodDef | undefined;
+/** 沿继承链查找方法，返回定义与所在类名 */
+declare function lookupMethodWithOwner(env: AstEnv, receiver: Abs, methodName: string): {
+    def: MethodDef;
+    owner: string;
+} | undefined;
+/** super.method()：从父类开始找（跳过当前类） */
+declare function lookupSuperMethod(env: AstEnv, receiver: Abs, fromClass: string, methodName: string): {
+    def: MethodDef;
+    owner: string;
+} | undefined;
+declare function wrapPromise(inner: Abs): Abs;
+declare function awaitAbs(v: Abs): Abs;
+declare function coerceAsyncReturn(value: Abs): Abs;
+/** 从 ClassMethod 列表构造 methods map + instance shape */
+declare function classFromMethods(name: string, methods: MethodDef[], superClass?: string, superShape?: Abs): ClassDef;
+
+declare function hashSource(s: string): string;
+declare function resetHashSourceCache(): void;
+
+/**
+ * Analysis-stable source key: strip trailing noise that cannot affect types.
+ * Keeps every line that may carry @nudo directives.
+ *
+ * Fast path: already-stable sources return the same string identity (O(1)
+ * compare in B-path / analysis caches when the caller reuses the buffer).
+ */
+declare function stableAnalyzeKeySource(source: string): string;
+
+/**
+ * per-function fingerprint: after-edit only dirty fn + callers miss L0.
+ *
+ * - own: function declaration slice (incl. leading comments / refine)
+ * - deps: transitively referenced sibling own hashes + non-fn top-level context
+ * - context change (import/class/const...) -> all miss (conservative)
+ *
+ * Multi-declarator `const a = fn, b = fn` yields one fingerprint per function;
+ * each own-slice is its own declarator (first also carries statement leading comments).
+ */
+
+type FnFp = {
+    own: string;
+    deps: string;
+    nRefs: number;
+};
+declare function resetFnFpCache(): void;
+type FnDeclInfo = {
+    name: string;
+    body: Node;
+    /** Function/arrow node (own-slice end; also scanned for sibling refs incl. defaults). */
+    fnNode: Node;
+    /** Declarator start when from a VariableDeclaration; else undefined. */
+    declaratorStart?: number;
+    /** First leading-comment start on this declarator (multi-decl refine/@nudo). */
+    declaratorLeadStart?: number;
+};
+/** Every top-level function binding in a declaration node (not just the first). */
+declare function getFnNameAndBodies(decl: Node): FnDeclInfo[];
+/** source -> (fnName -> own/deps); LRU */
+declare function fnFingerprints(source: string, file: File): Map<string, FnFp>;
+/** L0 source part: per-fn fingerprint when AST available; else full-file hash */
+declare function generalizeSourceKeyPart(source: string, fnName: string, file?: File): string;
+/**
+ * 无 refine、无模块语法、无兄弟调用、无任何调用表达式 → scanLiteralCalls 可整段跳过。
+ * 必须保守：`const x = f(-1)` / `if (f(-1))` / `require("x")` 都含 CallExpression，
+ * 只认顶层 ExpressionStatement 会漏报约束违规。
+ */
+declare function canSkipLiteralCallScan(source: string, file: File): boolean;
+
+/**
+ * check 报告面：数据模型 + 渲染/序列化。
+ *
+ * 分析在 check.ts（Abs 优先的 Nudo 原生诊断），这里只投影：
+ * - formatCheckReport → 人类可读文本
+ * - serializeCheckJson → `nudo check --json` 稳定契约（CI / Agent，v1）
+ */
+
+/** 无损函数签名（类型即计算） */
+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;
+
+/**
+ * nudo check 门禁：对源码跑代数分析，产出 error/warning。
+ *
+ * 报告是 **Nudo 原生格式**（Abs 优先），不是 TS 诊断的换皮：
+ * - 签名表给出无损 Abs（shape/term/pred/conf）
+ * - 违例写清 actual ⊭ expected（实参 Abs vs 前置 Pred）
+ * - dts/TS 兼容不是本报告的职责
+ */
+
+declare function resetCheckSourceMemo(): void;
+declare function getCheckSourceMemoSize(): number;
+/** `*.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;
+};
+/**
+ * 检查一个文件：
+ * - 每个顶层函数 generalize；无法得到任何签名 → warning
+ * - 若 source 中有字面量调用 `f(负数)` 且 f 有 `>0` 约束 → error
+ * - entry 结果 partial/opaque → info
+ *
+ * 默认 Φ（pTrue）走整文件 memo：同 source + deps + loadModule 身份 → O(1)。
+ */
+declare function checkSource(filePath: string, source: string, phi?: Phi, opts?: CheckOptions): CheckReport;
+
+/**
+ * Abs inlay hint：把无损约束内联到源码位置。
+ * 不是 TS 风格 type annotation 复读，而是 term/pred/conf 的计算结果。
+ */
+type AbsInlay = {
+    /** 1-based 行号 */
+    line: number;
+    /** 0-based 列（label 插入点） */
+    character: number;
+    label: string;
+    kind: "type" | "parameter";
+};
+/**
+ * 收集源码中函数签名的 Abs inlay：
+ * - 参数后：前置约束（声明 refine 优先；否则从 if 推）
+ * - `)` 后：返回 shape + term（类型即计算）
+ */
+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;
+
+/**
+ * B 路径运行时：transpile 后的程序在 Node 上执行时，值就是 Abs。
+ * 与 AST 解释器语义同构；TypeValue 不再是求值载体。
+ */
+
+declare function currentExecPhi(): Phi;
+declare function withExecPhi<T>(p: Phi, body: () => T): T;
+declare function $add(a: Abs, b: Abs): Abs;
+declare function $sub(a: Abs, b: Abs): Abs;
+declare function $mul(a: Abs, b: Abs): Abs;
+declare function $div(a: Abs, b: Abs): Abs;
+declare function $mod(a: Abs, b: Abs): Abs;
+declare function $neg(a: Abs): Abs;
+declare function $typeof(a: Abs): Abs;
+declare function $not(a: Abs): Abs;
+declare function $eq(a: Abs, b: Abs): Abs;
+declare function $ne(a: Abs, b: Abs): Abs;
+declare function $lt(a: Abs, b: Abs): Abs;
+declare function $le(a: Abs, b: Abs): Abs;
+declare function $gt(a: Abs, b: Abs): Abs;
+declare function $ge(a: Abs, b: Abs): Abs;
+declare function $join(a: Abs, b: Abs): Abs;
+/**
+ * transpile 泄漏的 JS 函数值 → 一等 fn Abs。
+ * B 路径把函数声明/表达式编译成真实 JS 函数；它们流进对象槽、
+ * 元组、join 等 Abs 结构时不能裸存——下游（bridge/leq/join）读 `.shape`。
+ * 参数名无法从运行时函数恢复（用 fn.length → argN，与 analyzer 的
+ * extractParamNames 回退口径一致）；带真实参数名走 $fnVal（transpile 侧）。
+ */
+declare function asAbsVal(v: unknown): Abs;
+/** 函数表达式 → 一等 fn Abs（transpile 侧带真实参数名；异步 body 包 $async） */
+declare function $fnVal(params: string[], impl: (...args: Abs[]) => Abs): Abs;
+/** 字面量 → Abs（transpile 侧数字/字符串/布尔/null/undefined） */
+declare function $lit(v: unknown): Abs;
+declare function isDefinitelyTrue(a: Abs): boolean;
+declare function isDefinitelyFalse(a: Abs): boolean;
+/**
+ * if：两侧都探索（抽象条件），具体条件短路。
+ */
+declare function $fork(test: Abs, consequent: () => Abs, alternate?: () => Abs): Abs;
+declare const DEFAULT_MAX_LOOP_ITERS = 8;
+/**
+ * for 的惰性展开：生成器只负责「按上限吐状态」。
+ * 抽象条件无法诚实终止——消费者必须自带 maxIters。
+ */
+declare function $forIter(init: Abs, test: (s: Abs) => Abs, step: (s: Abs) => Abs, body: (s: Abs) => Abs, maxIters?: number): Generator<{
+    state: Abs;
+    test: Abs;
+    afterBody: Abs;
+}, void, void>;
+/**
+ * 有界 for：unroll ≤ maxIters，每步「可能退出」的态 join；
+ * 相邻态 leq 视为不动点提前停。
+ */
+declare function $for(init: Abs, test: (s: Abs) => Abs, step: (s: Abs) => Abs, body: (s: Abs) => Abs, maxIters?: number): Abs;
+/** 数组字面量 → Abs tuple（长度已知） */
+declare function $arr(items: Abs[]): Abs;
+/** 下标读 a[i]；字面量 i 走 tuple 精确投影，否则并所有元素 */
+declare function $idx(a: Abs, i: Abs): Abs;
+/** 下标写 a[i]=v → 新 tuple */
+declare function $idxSet(a: Abs, i: Abs, value: Abs): Abs;
+/** 数组长度 */
+declare function $len(a: Abs): Abs;
+/** 对象字面量 → Abs obj */
+declare function $obj(slots: Record<string, Abs>): Abs;
+/** 对象展开 { ...a, b } */
+declare function $spread(a: Abs, b: Abs): Abs;
+/** 数组连接 [...a, ...b] / [...a, x] */
+declare function $concat(a: Abs, b: Abs): Abs;
+/** 元素列表（tuple 展开；arr 抽象） */
+declare function $elems(a: Abs): Abs[];
+/**
+ * for-of：对 iterable 每个元素跑 body；有界展开。
+ * body(item, i) 可返回 void；状态由外部 JS 变量承接。
+ */
+declare function $forOf(iterable: Abs, body: (item: Abs, index: Abs) => void, maxIters?: number): void;
+/** 成员读：obj.slots[key]；缺失 → undefined 字面量；brand 解包内层 */
+declare function $get(o: Abs, key: string, opts?: {
+    silent?: boolean;
+}): Abs;
+/** 成员写：返回新 obj/brand（不可变更新） */
+declare function $set(o: Abs, key: string, value: Abs): Abs;
+/**
+ * 有界 while：state 线程穿 test/step（与 $for 同折叠语义）。
+ * 抽象条件无法诚实终止——必须 maxIters。
+ */
+declare function $while(init: Abs, test: (s: Abs) => Abs, step: (s: Abs) => Abs, maxIters?: number): Abs;
+/**
+ * 顺序 while（具体/可变闭包）：body 内对 JS 变量赋值。
+ * 适合 transpile `let i; while (…) { i = … }`；抽象条件仍靠预算截断，
+ * 不保证 exit-join 健全——健全路径用 $while/$for + 状态对象。
+ */
+declare function $whileSeq(test: () => Abs, body: () => void, maxIters?: number): void;
+/** B 路径 throw 载荷：携带 Abs 抛出值 */
+declare class NudoThrow extends Error {
+    readonly absValue: Abs;
+    constructor(absValue: Abs);
+}
+/** transpile `throw x` → `$throw(x)` */
+declare function $throw(v: Abs): never;
+declare function isNudoThrow(e: unknown): e is NudoThrow;
+/** catch 参数：从 NudoThrow 取出 Abs，否则 unknown */
+declare function $catchVal(e: unknown): Abs;
+/**
+ * async 函数体包进 thunk，返回值经 wrapPromise。
+ */
+declare function $async(thunk: () => Abs): Abs;
+/** await → 解包 eff("promise") */
+declare function $await(v: Abs): Abs;
+/** async 直接 return 的 coerce */
+declare function $asyncReturn(v: Abs): Abs;
+/** function* 体：收集所有 yield 值为 tuple Abs */
+declare function $gen(body: () => void): Abs;
+/** yield v：压入当前生成器收集器；表达式值用 unknown */
+declare function $yield(v: Abs): Abs;
+/**
+ * switch：具体 disc 选中匹配 case；抽象 disc 并所有分支。
+ */
+declare function $switch(disc: Abs, cases: Array<{
+    test: Abs;
+    run: () => Abs;
+}>, dflt?: () => Abs): Abs;
+
+/**
+ * B 路径 transpile：JS AST → 可在 Node 上执行的抽象值程序（源码字符串）。
+ * 运算符改为 $add/$sub/…；if 改为 $fork；for 改为 $for。
+ * 值类型是 Abs；副作用与模块仍由 host mock/注入。
+ */
+
+type TranspileOptions = {
+    /** 运行时 import 说明符 */
+    runtimeImport?: string;
+    maxLoopIters?: number;
+    /** 方法体内 this 的绑定名（transpile class 时注入） */
+    thisParam?: string;
+    /** 当前类名（super 派发用） */
+    className?: string;
+    /** 原始源码（@nudo:replace 按节点文本匹配） */
+    source?: string;
+    /** 替换表：归一化目标文本 → 注入变量名；可选语句范围 */
+    replacements?: Array<{
+        target: string;
+        varName: string;
+        /** 仅该语句范围内生效（1-based 行） */
+        stmtStart?: number;
+        stmtEnd?: number;
+    }>;
+    /** @nudo:as：覆盖紧随语句的 init / return */
+    asOverrides?: Array<{
+        varName: string;
+        stmtStart: number;
+        stmtEnd: number;
+    }>;
+};
+declare function transpileSource(source: string, opts?: TranspileOptions): string;
+declare function transpileFile(file: File, opts?: TranspileOptions): string;
+declare function transpileExpression(expr: Expression, opts?: TranspileOptions): string;
+/** 解析 + transpile */
+declare function transpile(source: string, opts?: TranspileOptions): string;
+
+/**
+ * 调用 Abs 一等函数（absFunction impl）或 mock apply。
+ * 供 B 路径 import 绑定包装：`(...args) => $call(absFn, args)`。
+ */
+
+declare function $call(fn: Abs, args: Abs[]): Abs;
+
+/**
+ * B class 规格表（无 call/ast-eval 依赖，避免循环）。
+ * Abs-eval registerClassDecl 与 transpile $class 共用。
+ */
+
+type BClassSpec = {
+    name: string;
+    superName?: string;
+    ctor?: (thisVal: Abs, ...args: Abs[]) => Abs;
+    methods?: Record<string, (thisVal: Abs, ...args: Abs[]) => Abs>;
+    staticMethods?: Record<string, (...args: Abs[]) => Abs>;
+    statics?: Record<string, Abs>;
+};
+declare function registerBClass(spec: BClassSpec): void;
+declare function getBClass(name: string): BClassSpec | undefined;
+declare function clearBClasses(): void;
+
+/**
+ * B 路径 class：brand 实例 + ctor/method 闭包 + 继承链。
+ * 方法内 this 由 transpile 改写为 thisVal 参数。
+ */
+
+/** 定义类 → 可 new 的 Abs（brand 标记；静态字段挂在 slots） */
+declare function $class(name: string, spec: Omit<BClassSpec, "name"> & {
+    extends?: string;
+}): Abs;
+/** new C(...) → 空 brand 实例 + ctor 写字段；非类构造走 impl/$call */
+declare function $new(cls: Abs | ((...a: unknown[]) => unknown), args: Abs[]): Abs;
+/**
+ * super(...)：父类构造写入字段（this 保持子类 brand）。
+ * transpile: super(a,b) → __this = $super(__this, "Child", [a,b])
+ */
+declare function $super(thisVal: Abs, childName: string, args: Abs[]): Abs;
+/** 实例方法调用：沿继承链；类 Abs 上回落 staticMethods；obj 上回落属性函数 */
+declare function $invoke(thisVal: Abs, method: string, args: Abs[], loc?: [number, number]): Abs;
+/** super.method()：从父类起找（跳过自身覆盖） */
+declare function $invokeSuper(thisVal: Abs, childName: string, method: string, args: Abs[]): Abs;
+declare function $thisGet(thisVal: Abs, key: string): Abs;
+declare function $thisSet(thisVal: Abs, key: string, value: Abs): Abs;
+/** 解构默认值：undefined 时用 default */
+declare function $orDefault(v: Abs, dflt: () => Abs): Abs;
+/** 可选链 a?.b：nullish 短路为 undefined 字面量 */
+declare function $optionalGet(o: Abs, key: string): Abs;
+/** 可选链 a?.m()：nullish 短路为 undefined */
+declare function $optionalInvoke(thisVal: Abs, method: string, args: Abs[]): Abs;
+/** 静态方法：cls.staticMethod(args) */
+declare function $staticInvoke(cls: Abs, method: string, args: Abs[]): Abs;
+/** 计算属性写：o[kAbs] = v */
+declare function $setKey(o: Abs, key: Abs, value: Abs): Abs;
+
+/**
+ * 成员缺失诊断（B 路径 + Abs ast-eval 共用）。
+ * 无 $call / transpile 依赖，避免 ast-eval ↔ calls 循环。
+ */
+
+type BMemberDiag = {
+    kind: "method" | "property";
+    name: string;
+    /** 接收者 prim 类型名，或 "unknown" */
+    receiver: string;
+    line?: number;
+    column?: number;
+    /** 调用点来源（provenance）：实参字面量 loc 优先，否则最近 $callNamed loc */
+    origin?: {
+        line: number;
+        column: number;
+    };
+};
+/** 给实参 Abs 打 provenance（调用点参数字面量） */
+declare function tagAbsOrigin(a: Abs, loc: {
+    line: number;
+    column: number;
+}): void;
+declare function getAbsOrigin(a: Abs | undefined): {
+    line: number;
+    column: number;
+} | undefined;
+declare function setMemberDiagCollector(c: ((d: BMemberDiag) => void) | null): void;
+declare function recordMemberDiag(d: BMemberDiag): void;
+/**
+ * prim 接收者上的未知成员 → 诊断。
+ * 返回 true 表示确定缺失（number 上任意方法；string 上表外方法）。
+ */
+declare function notePrimMemberMissing(recv: Abs | undefined, name: string, kind: "method" | "property", loc?: [number, number]): boolean;
+/**
+ * unknown 接收者上的成员访问 → unknown-recv（与 TypeValue 口径对齐：
+ * object/instance/refined/promise 静默；其余记一条）。
+ */
+declare function noteUnknownMemberMissing(recv: Abs | undefined, name: string, kind: "method" | "property", loc?: [number, number]): boolean;
+/** 方法分派失败时的统一记账（prim / unknown；obj/brand/promise 静默） */
+declare function noteMemberDispatchMiss(recv: Abs | undefined, name: string, kind: "method" | "property", loc?: [number, number]): void;
+
+/**
+ * B 路径调用点记录：transpile 把 `f(args)` 改成 $callNamed，
+ * 分析时可收集 call@ 所需的 AbsCallRecord。
+ * 成员缺失诊断见 member-diag.ts（与 ast-eval 共用，避免循环依赖）。
+ */
+
+type BCallRecord = {
+    fnName: string;
+    args: Abs[];
+    result: Abs;
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    threw?: boolean;
+};
+declare function setBCallCollector(collector: ((r: BCallRecord) => void) | null): void;
+declare function getBCallCollector(): ((r: BCallRecord) => void) | null;
+/**
+ * 按名调用并记录。
+ * loc: [line, column]（1-based line，0-based column，与 Babel 一致）
+ * argLocs: 与 args 对齐的实参字面量源位置（provenance；无 loc 用 null）
+ */
+declare function $callNamed(name: string, fn: unknown, args: Abs[], loc?: [number, number], argLocs?: Array<[number, number] | null | undefined>): Abs;
+
+/**
+ * 进程内 B 路径执行：transpile 源码 → new Function 跑在 runtime 上。
+ * 不写临时文件；相对 import 用注入的 AbsModuleExports / JS 导出绑定。
+ *
+ * mode:
+ * - "exec"（默认）：执行全部顶层（含副作用）
+ * - "analyze"：只保留函数声明与纯字面量 const；跳过顶层表达式/循环/if
+ *   ——分析入口安全，不触发 fetch 等顶层副作用
+ */
+
+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>;
+};
+/**
+ * 执行一段 B 路径程序，返回顶层 `export function` / `export const`。
+ */
+declare function runTranspiled(source: string, opts?: RunTranspiledOptions): Record<string, unknown>;
+type TranspiledCallResult = {
+    result: Abs;
+    /** 非 never 表示函数可能 throw 该类型 */
+    throws: Abs;
+};
+/** 调用 runTranspiled 导出（捕获 $throw） */
+declare function callTranspiledExportFull(exports: Record<string, unknown>, name: string, args: Abs[]): TranspiledCallResult;
+/** 调用 runTranspiled 导出（仅结果） */
+declare function callTranspiledExport(exports: Record<string, unknown>, name: string, args: Abs[]): Abs;
+
+/**
+ * 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 转 TypeValue 后是否丢了 term/pred。
+ * 用于金标与调试。
+ */
+declare function bridgeIsLossy(a: Abs): {
+    lossy: boolean;
+    reasons: string[];
+};
+
+export { $add, $arr, $async, $asyncReturn, $await, $call, $callNamed, $catchVal, $class, $concat, $div, $elems, $eq, $fnVal, $for, $forIter, $forOf, $fork, $ge, $gen, $get, $gt, $idx, $idxSet, $invoke, $invokeSuper, $join, $le, $len, $lit, $lt, $mod, $mul, $ne, $neg, $new, $not, $obj, $optionalGet, $optionalInvoke, $orDefault, $set, $setKey, $spread, $staticInvoke, $sub, $super, $switch, $thisGet, $thisSet, $throw, $typeof, $while, $whileSeq, $yield, type Abs, type AbsAssignRecord, type AbsCallRecord, type AbsFnImpl, type AbsInlay, type AbsModuleExports, type AstEnv, type BCallRecord, type BClassSpec, type BMemberDiag, type CheckIssue, type CheckJson, type CheckOptions, type CheckReport, type ClassDef, type Confidence, type ConstraintBuilder, DEFAULT_MAX_LOOP_ITERS, type Diagnostic, type Environment, type EvalOptions, type EvalResult, type FnAbs, type FnFp, type FormatOptions, type FunctionSignature, type LeakBudget, type LeqResult, type LiteralValue$1 as LiteralValue, type LoadDepsFingerprint, MAX_CALL_DEPTH, MAX_TOTAL_CALLS, type MethodDef, type MockHelper, type NamedImport, type NudoConstraint, type NudoField, type NudoSig, NudoThrow, type ObjShape, Ops, type Phi, type PolyFn, type Pred, type PrimName, type RangeMeta, type RefineEntry, type RefineResolveOpts, type Refinement, type RunTranspiledOptions, SELF, type Shape, type SigImpl, type Slot, T, type TemplateMeta, type Term, type TranspileOptions, type TranspiledCallResult, type TypeParam, type TypeValue, abs, absFunction, absToString, absToTypeValue, add, analyzeFn, and, anyVar, app, applyBinaryOp, array, asAbsVal, attachFnImpl, awaitAbs, bindImports, bool, boolLit, boolean, bridgeIsLossy, buildArgsFromAssume, callAbsMethod, callFunction, callTranspiledExport, callTranspiledExportFull, canSkipLiteralCallScan, checkArg, checkCall, checkSource, classFromMethods, clearBClasses, cmp, coerceAsyncReturn, collapseLiteralUnion, collapseToOptional, collectAbsExports, collectAbsInlays, collectAbsNodeTypes, concatString, concatTemplates, confJoin, constraintToEntryAbs, createEnvironment, createRange, createTemplate, createTemplateAbs, currentExecPhi, currentPhi, deepCloneTypeValue, defaultLeakBudget, defineClass, definitelyNotNullishShape, denoteGuard, describePhi, dispatchBinaryOp, dispatchMethod, dispatchProperty, div, emptyEnv, emptyPhi, eq, 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, extractNudoImports, extractRefineReturnFromSource, extractRefinesFromSource, falseConstraint, findAbsAtPosition, fnFingerprints, fnOf, formatAbs, formatAbsMultiline, formatCheckReport, formatDiagnostics, formatShape, ge, geNum, generalizeAll, generalizeFromAst, generalizeSourceKeyPart, getAbsOrigin, getAbsProperty, getBCallCollector, getBClass, getCheckSourceMemoSize, getClass, getClassChain, getFnImpl, getFnNameAndBodies, getFnSig, getGeneralizeMemoSize, getKnownPrefix, getKnownSuffix, getParseSourceCacheSize, getPrimitiveTypeOf, getRangeMeta, getRefinedBase, getTemplateParts, getTerm, getTvConfidence, gt, gtNum, hashSource, implies, instanceOf, instantiateClass, instantiateConstraint, isDefinitelyFalse, isDefinitelyTrue, isExactLit, isFnSig, isNudoConstraint, isNudoThrow, isNullishLitAbs, isNumPrim, isObj, isRange, isStrPrim, isSubtypeOf, isTemplate, isTemplateLike, joinAbs, joinFunctions, joinObjects, joinValues, le, leNum, leakIfNeeded, lenTerm, leqAbs, listFunctionNames, lit, litValue, loadModuleDepsFingerprint, lookupMethod, lookupMethodWithOwner, lookupSuperMethod, lt, ltNum, makeSum, maybeLeak, mergeObjectProperties, mock, mockHelperToTypeValue, mod, mul, narrowType, ne, negAbs, never, normPath, not, notAbs, noteMemberDispatchMiss, notePrimMemberMissing, noteUnknownMemberMissing, num, numLit, numVar, number, numericBounds, obj, objOf, or, pFalse, pTrue, parseSource, phiAnd, popPhi, predEquals, predToString, predVars, projectBrand, ptypeof, pushPhi, recordMemberDiag, refineToIndexedFull, registerBClass, resetAbsCallBudget, resetCheckSourceMemo, resetFnFpCache, resetGeneralizeMemo, resetHashSourceCache, resetLeakCounter, resetNudoModuleExecCache, resetParseSourceCache, resetPhi, resolveDepPath, runTranspiled, serializeCheckJson, setAbsAssignCollector, setAbsCallCollector, setAbsNodeCollector, setAbsTruncationCollector, setBCallCollector, setMemberDiagCollector, setTvConfidence, shape, shapeOfTerm, shapeToString, simplifyTerm, simplifyUnion, spread, spy, stableAnalyzeKeySource, str, strLit, strictEqAbs, string, stripTypes, stub, sub, substPred, subtractType, superNameOf, tagAbsOrigin, templatePartsOf, termDepth, termEquals, termNodes, termToString, transpile, transpileExpression, transpileFile, transpileSource, trueConstraint, typeValueEquals, typeValueToAbs, typeValueToString, typeofAbs, unknown, v, widenLiteral, withExecPhi, withPhiConstraint, withVar, wrapPromise };