@nudojs/core 1.0.0 → 1.1.0

package/dist/index-B7Lb8FU6.d.ts

@@ -0,0 +1,726 @@
+import { A as Abs, M as MayThrowEffect, b as Phi, c as AstEnv } from './hof-types-tAeoYvzY.js';
+import * as _babel_types from '@babel/types';
+import { Node, Expression, File, ImportDeclaration } from '@babel/types';
+
+/**
+ * B 路径 throw 载荷（独立叶子模块）：
+ * builtins.ts（evalJsonMethod 等 Abs builtin）需要硬抛 TypeError/SyntaxError，
+ * 而 exec/runtime.ts 又 import builtins.ts（evalNamespaceCall 等）——
+ * 直接互引成环。NudoThrow 无依赖（仅 Abs 类型 + Error），抽成叶子，
+ * runtime.ts re-export 保持既有 import 面不变。
+ */
+
+/** B 路径 throw 载荷：携带 Abs 抛出值 */
+declare class NudoThrow extends Error {
+    readonly absValue: Abs;
+    constructor(absValue: Abs);
+}
+declare function isNudoThrow(e: unknown): e is NudoThrow;
+
+/**
+ * B 路径运行时共享状态：phi、就地写、字面量 Abs、真值、循环信号。
+ * 叶子模块——不依赖 runtime 其它文件（tuple/obj 字面量就地构造，避免 state↔containers 环）。
+ */
+
+/** 调用方已直接改 shape 时的 term/pred 清理 */
+declare function clearStaleTermPred(v: Abs): void;
+declare function currentExecPhi(): Phi;
+declare function withExecPhi<T>(p: Phi, body: () => T): T;
+/**
+ * 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;
+/**
+ * 函数调用边界：callee 的 loop/early-return 不得冒泡成 caller 结果。
+ * 每个 B 路径调用帧独立 ALS；NudoReturn 收成该调用的返回值。
+ */
+declare function callAtFunctionBoundary<T>(body: () => T): T;
+/** 函数表达式 → 一等 fn Abs（transpile 侧带真实参数名；异步 body 包 $async）
+ *  opts.bindThis：对象方法——$invoke 会把 receiver 作为 impl 首参注入。 */
+declare function $fnVal(params: string[], impl: (...args: Abs[]) => Abs, opts?: {
+    bindThis?: boolean;
+}): Abs;
+/**
+ * 宿主 this → Abs：函数体 prologue 用它承接 call/apply/bind 传入的 thisArg。
+ * Abs 原样返回；宿主 undefined（普通调用/call 缺 thisArg）→ $lit(undefined)。
+ * B 路径产物是 new Function 拼接（sloppy），裸调用的宿主 this 泄漏为
+ * globalThis——归一到 $lit(undefined)（strict 模块语义下的 this）。
+ */
+declare function $rawThis(v: unknown): Abs;
+/** 字面量 → Abs（transpile 侧数字/字符串/布尔/null/undefined） */
+declare function $lit(v: unknown): Abs;
+/** JS 真值：字面量按 Boolean(v)；对象形恒真；不可判 → undefined */
+declare function litTruth(a: Abs): boolean | undefined;
+declare function isDefinitelyTrue(a: Abs): boolean;
+declare function isDefinitelyFalse(a: Abs): boolean;
+/** 函数求值作用域：收集抽象分支上的 early-return / throw 值；try 标记栈同边界 */
+declare function runWithLoopExits<T>(body: () => T): T;
+declare function takeLoopExits(): Abs[];
+declare function takeThrowExits(): Abs[];
+declare function pushLoopExit(v: Abs): void;
+declare function pushThrowExit(v: Abs): void;
+/** transpile 生成代码用：`$pushLoopExit` */
+declare function $pushLoopExit(v: Abs): void;
+/** try 块开始：压栈 hard/soft 标记 */
+declare function $tryMark(): number;
+/** 当前最内层 try 的 mark（return 时 drain 用；嵌套调用不串栈） */
+declare function $tryCurrentMark(): number;
+declare function $tryPopMark(): void;
+/** 取出 mark 之后新记录的 throw（try 吸收 / catch 合并） */
+declare function $tryTakeSince(mark: number): Abs[];
+/** catch 入口消化 try 内 soft may-throw（幂等；design §3.3） */
+declare function $tryDigestSoftCatch(): void;
+/**
+ * 正常完成路径 + catch 可能 rethrow：soft 效果不得消化——假想 soft throw
+ * 经 catch rethrow 逃逸（try { u.name } catch (e) { throw e; } 的 L2）。
+ * 摘帧上浮（collector / 外层 try 帧可再消化），并清 soft 标记防二次释放。
+ */
+declare function $tryReleaseSoftCatch(): void;
+/**
+ * catch 入口摘下 soft 效果（不消化）。catch 正常落出口再 discard；
+ * catch rethrow 时 orphan 上浮（外层 try 可再消化）。
+ */
+declare function $tryDetachSoftCatch(): MayThrowEffect[];
+/** catch 无 rethrow 落出口：丢弃已摘下的 soft（design：catch 消化） */
+declare function $tryDiscardSoft(_effects: MayThrowEffect[]): void;
+/** catch rethrow：摘下的 soft 上浮（嵌套 try 归外层帧） */
+declare function $tryOrphanSoft(effects: MayThrowEffect[]): void;
+/** 无 handler / 出口：上浮未消化 soft may-throw（幂等） */
+declare function $tryReleaseSoftOut(): void;
+/** B 路径「函数提前 return」信号（区别于 throw） */
+declare class NudoReturn extends Error {
+    readonly absValue: Abs;
+    constructor(absValue: Abs);
+}
+declare function isNudoReturn(e: unknown): e is NudoReturn;
+/** transpile `return x` inside for/while → `$loopReturn(x)` */
+declare function $loopReturn(v: Abs): never;
+/**
+ * break/continue 信号：transpile 在循环体内生成 $loopBreak/$loopContinue，
+ * $for/$whileSeq/$forOf 在 body 调用点捕获。带标签信号只被同标签循环吸收，
+ * 不匹配继续冒泡到外层循环（`break outer` / `continue outer` 语义）。
+ */
+declare class NudoLoopSignal extends Error {
+    readonly kind: "break" | "continue";
+    readonly label: string | undefined;
+    constructor(kind: "break" | "continue", label?: string);
+}
+declare function $loopBreak(label?: string): never;
+declare function $loopContinue(label?: string): never;
+declare function isNudoBreak(e: unknown, label?: string): boolean;
+declare function isNudoContinue(e: unknown, label?: string): boolean;
+/** 非循环 labeled block：判断 break 信号是否指向本标签（transpile 生成代码用） */
+declare function $isBreakTo(e: unknown, label: string): boolean;
+/** catch 转译辅助：控制流信号透传（生成代码只注入 `$` 前缀符号） */
+declare function $rethrowIfNudoReturn(e: unknown): void;
+
+/**
+ * 运算符重载面（transpile 目标）：$add/$sub/…、比较/位运算。
+ */
+
+declare function $unknown(): Abs;
+/** `import.meta` → `{ url: string }`（宿主 URL 非字面量，不假精确） */
+declare function $importMeta(): Abs;
+/** `import(spec)` → Promise&lt;开放模块命名空间&gt;（动态模块图不静态解析） */
+declare function $dynamicImport(_spec: Abs): Abs;
+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 $bitand(a: Abs, b: Abs): Abs;
+declare function $bitor(a: Abs, b: Abs): Abs;
+declare function $bitxor(a: Abs, b: Abs): Abs;
+declare function $bitnot(a: Abs): Abs;
+declare function $shl(a: Abs, b: Abs): Abs;
+declare function $shr(a: Abs, b: Abs): Abs;
+declare function $ushr(a: Abs, b: Abs): Abs;
+declare function $pow(a: Abs, b: Abs): Abs;
+declare function $toNumber(a: 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;
+/** `==` / `!=`（C2.3）：双字面量 Abstract Equality，否则回落严格判定 */
+declare function $eqLoose(a: Abs, b: Abs): Abs;
+declare function $neLoose(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;
+
+/**
+ * 访问器（get/set）侧表、in / instanceof / delete 路由。
+ */
+
+/** 注册对象字面量访问器（transpile 调用；返回原 obj 以便链式包裹） */
+declare function $objAccessor(o: Abs, key: string, get: ((t: Abs) => Abs) | null, set: ((t: Abs, v: Abs) => Abs) | null): Abs;
+/** 对象字面量访问器查询（供 $get/$set/$spread/Object.assign 共用） */
+declare function lookupObjAccessor(o: Abs, key: string): {
+    get?: (t: Abs) => Abs;
+    set?: (t: Abs, v: Abs) => Abs;
+} | undefined;
+/**
+ * `key in obj`：闭形状精确判定（含 Object.prototype 名、数组下标/length、
+ * class 方法/访问器与内建 brand 方法）；prim/nullish 接收者原生抛 TypeError →
+ * unknown；抽象键/开形状 → boolean。
+ */
+declare function $in(key: Abs, o: Abs): Abs;
+/**
+ * `x instanceof Right`（Right 为标识符名）：按左值形状精确判定。
+ * nullish 左侧原生抛 TypeError → unknown；未知用户构造器名 → boolean（不得 exact false）。
+ */
+declare function $instanceof(left: Abs, rightName: string, rightVal?: Abs): Abs;
+/** instanceof 右操作数非标识符（表达式/成员路径）：构造器值未知 → 抽象 boolean */
+declare function $instanceofNonIdent(_left: Abs): Abs;
+/** ClassExpression 值：构造器函数形状，不得折成精确 undefined */
+declare function $classExpr(): Abs;
+/**
+ * `delete obj[key]` 的结果判定（只读，不写回）。
+ * frozen/sealed 或 configurable:false 键 → false；preventExtensions 可删；
+ * closed 目标恒 true（其余 non-configurable 形态不建模）；
+ * prim/nullish 接收者原生抛 TypeError → unknown。
+ */
+declare function $delRes(o: Abs, _key: Abs): Abs;
+/**
+ * `delete obj[key]` 的写入（不可变更新）：返回删键后的新容器。
+ * 闭对象删自有槽；tuple 规范下标置 undefined（对齐原生空洞读值）；
+ * 抽象 arr 元素并入 undefined；无法表达的形态原样返回。
+ */
+declare function $del(o: Abs, key: Abs): Abs;
+
+/**
+ * 循环展开上限（leaf）—— 从 control.ts 拆出，打断 control ↔ containers 环。
+ */
+declare const DEFAULT_MAX_LOOP_ITERS = 8;
+
+declare function $fork(test: Abs, consequent: () => Abs, alternate?: () => Abs): Abs;
+
+/**
+ * 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, opts?: {
+    pack?: () => Abs;
+    unpack?: (s: Abs) => void;
+    /** 标签循环（`outer: for …`）：仅吸收同标签 break/continue 信号 */
+    label?: string;
+}): 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 变量赋值。
+ * 提供 pack/unpack 时，抽象条件的可能出口会 join 回绑定（P0 健全）；
+ * 未 instrument 的调用保持旧语义（预算截断，文档已声明）。
+ */
+declare function $whileSeq(test: () => Abs, body: () => void, maxIters?: number, opts?: {
+    /** 把当前绑定收成 Abs 状态（transpile 注入） */
+    pack?: () => Abs;
+    /** 把 join 后的状态写回绑定 */
+    unpack?: (s: Abs) => void;
+    /** 标签循环：仅吸收同标签 break/continue 信号 */
+    label?: string;
+}): void;
+declare function $switch(disc: Abs, cases: Array<{
+    test: Abs;
+    run: () => Abs;
+}>, dflt?: () => Abs): Abs;
+/** transpile `throw x` → `$throw(x)` */
+declare function $throw(v: Abs): never;
+/**
+ * fork 臂是否以控制流退出（return / throw）。
+ * 生成代码用此决定 continue-path free-write 标志：退出臂的写
+ * 不得污染 join 后的 continue 绑定。
+ */
+declare function $isForkExit(e: unknown): boolean;
+/** catch 参数：从 NudoThrow 取出 Abs；宿主 Error 补 name/message；否则 unknown */
+declare function $catchVal(e: unknown): Abs;
+
+/**
+ * 数组 / 对象运行时：$arr/$idx/$len/$arrMutContainer 与 $obj/$get/$set/$spread。
+ */
+
+/** 数组字面量 → ≤cap tuple（逐元素精确）/ >cap arr；策略与 containers.ts 同源 */
+declare function $arr(items: Abs[]): Abs;
+/**
+ * `arguments` 对象 → 类数组 tuple（$len/$idx 投影 length/下标；typeof 为 "object"）。
+ * strict/ESM 与形参**独立映射**：写 `arguments[i]` 不改形参，写形参不改 `arguments`。
+ * （sloppy 非严格是 mapped arguments object，二者互相写回——Nudo 分析按 ESM/strict。）
+ * 与 rest 绑定解耦：rest 仍从真实 `arguments`/rest 形参收集，本对象只服务用户写的 `arguments`。
+ */
+declare function $arguments(items: ArrayLike<unknown>): Abs;
+/**
+ * 带空洞的数组字面量（[1,,3]）：hole 槽位置为 undefined 值但 `in` 判定 false。
+ * 超 cap 退化 arr 时丢弃 hole 精度（元素 join，长度语义已由 arr 承接）。
+ */
+declare function $arrWithHoles(items: Abs[], holes: number[]): Abs;
+declare function isArrMutator(name: string): boolean;
+declare function fillTuple(shape: {
+    k: "tuple";
+    elements: Abs[];
+    holes?: number[];
+} | {
+    k: "arr";
+    element: Abs;
+}, vals: Abs[], arr: Abs): Abs;
+/**
+ * 深拷贝可变容器（fork/switch 快照与循环 pack 用）。
+ * 容器写就地进行后（引用语义），分析分支/迭代的状态分离必须靠拷贝——
+ * 浅引用快照会让臂间/迭代间互相污染。
+ */
+declare function $copy(a: Abs): Abs;
+/** 数组/元组方法（push/pop/shift/unshift/splice/reverse/sort/copyWithin/fill）
+ *  的就地 mutator：Abs 身份不变（JS 引用语义——`const b = a; b.push(4)` 对 a
+ *  可见）；transpile 重绑 `a = $arrMutContainer(a, …)` 仍写回同一对象。 */
+declare function $arrMutContainer(arr: Abs, method: string, args: Abs[]): Abs;
+/** 下标读 a[i]；字面量 i 走 tuple 精确投影，否则并所有元素；string[i] → 单字符 */
+declare function $idx(a: Abs, i: Abs): Abs;
+/** 下标写 a[i]=v → 新 tuple（越界写按 JS 语义增长，空洞为 undefined） */
+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;
+/**
+ * 解构 rest：`const { a, ...rest } = o` → rest = o 去掉 named keys。
+ * closed obj：剩余槽 closed；open / optional 键：rest 仍 open（可能有未知键）。
+ */
+declare function $objRest(o: Abs, keys: string[]): Abs;
+/** 数组 rest：`const [a, ...rest] = arr` → rest = 从 start 起的尾段 */
+declare function $arrRest(a: Abs, start: number): Abs;
+/** 数组连接 [...a, ...b] / [...a, x]；结果超 cap 时与字面量同策略降 arr */
+declare function $concat(a: Abs, b: Abs): Abs;
+/** 元素列表（tuple 展开；arr 抽象；C1 Set/Map 逐条目；matchAll 迭代器逐匹配项；
+ *  字符串按 code points）。Map 迭代语义是 entry `[key, value]` 元组，不是裸 value。 */
+declare function $elems(a: Abs): Abs[];
+/**
+ * for-of：对 iterable 每个元素跑 body；有界展开。
+ * body(item, i) 可返回 void；状态由外部 JS 变量承接。
+ * - 具体空 tuple：体 0 次（不得用 `length || maxIters` 展开成 maxIters）
+ * - 抽象 arr / 未知长度：0..maxIters 出口与 pack 状态 join
+ */
+/**
+ * for-in 键序列：原生顺序为整数键升序 → 其余键按插入序；
+ * 数组 hole 槽不出键（读值为 undefined 但不可枚举）。仅自有可枚举键。
+ */
+declare function $forInKeys(o: Abs): Abs;
+declare function $forOf(iterable: Abs, body: (item: Abs, index: Abs) => void, maxIters?: number, opts?: {
+    pack?: () => Abs;
+    unpack?: (s: Abs) => void;
+    /** 标签循环：仅吸收同标签 break/continue 信号 */
+    label?: string;
+}): void;
+/**
+ * 命名空间身份表：transpile 后 `Math.max(0, x)` 的接收者是宿主 JS 全局对象
+ * （非 Abs）。按对象身份识别命名空间，路由到 Abs builtin 表。
+ */
+declare function namespaceNameOf(v: unknown): string | undefined;
+/** 正则字面量 → RegExp brand（source/flags/lastIndex 进 slots，供 exec/test 精确执行） */
+declare function $regex(pattern: string, flags?: string): Abs;
+/** 成员读：obj.slots[key]；缺失 → undefined 字面量；brand 解包内层 */
+declare function $get(o: Abs, key: string, opts?: {
+    silent?: boolean;
+}): Abs;
+/**
+ * Map/Set forEach：条目表逐条调用回调（value, key, recv）。
+ * 回调是 B 路径 JS 函数（transpile 内联箭头）直接调用；Abs fn 走 $call。
+ * 回调返回值丢弃；forEach 表达式值恒 undefined。
+ */
+declare function $collectionForEach(recv: Abs, cb: unknown): Abs | undefined;
+/** 成员写：返回新 obj/brand（不可变更新）；frozen/sealed/只读目标按 sloppy 静默失败 */
+declare function $set(o: Abs, key: string, value: Abs): Abs;
+
+/**
+ * async / await / generator / $switch / $nullishTest。
+ */
+
+/**
+ * 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；抽象分支时降 conf（P0-6） */
+declare function $gen(body: () => void): Abs;
+/** yield v：压入当前生成器收集器；表达式值用 unknown */
+declare function $yield(v: Abs): Abs;
+/**
+ * switch：具体 disc 选中匹配 case；抽象 disc 并所有分支。
+ * 抽象路径与 $fork 同构：集合 side-table 按臂 overlay，共享 body 只跑一次；
+ * 臂内 NudoReturn/NudoThrow 不冒泡污染兄弟臂。
+ * **无 default 时必须隐式 fall-through 臂（undef）**，否则无匹配路径被丢掉（P0-2）。
+ */
+/** `??` / `??=` 测试：确定非 nullish → false；lit nullish → true；否则抽象 boolean */
+declare function $nullishTest(v: Abs): Abs;
+
+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;
+    }>;
+    /** 循环嵌套深度（>0 时 return → $loopReturn，C2.1） */
+    inLoop?: number;
+    /** 循环体/switch 臂内：无标签 break 语义分别为跳出循环信号 / 臂结束 return */
+    inSwitchArm?: boolean;
+    /** 标签循环名（`outer: for …`）：传给 $for/$whileSeq/$forOf 供信号匹配 */
+    loopLabel?: string;
+    /** 宽松全局：标识符调用 callee 未声明 → undefined（$callNamed 保守
+     *  unknown），模块不因 ReferenceError 中断——调用点发现的 exec 采集用
+     * （测试框架 it/describe/test 等未注入全局） */
+    lenientGlobals?: boolean;
+    /** try 嵌套深度（>0 时 return 前 drain throwExits，使 catch 能吸收抽象 throw） */
+    inTry?: number;
+    /** 当前 try 的 mark 变量名（return drain 用；避免全局栈顶污染） */
+    tryMarkName?: string;
+    /** 当前 try 是否带 catch handler（soft may-throw digest/release 分支） */
+    hasTryHandler?: boolean;
+    /** 当前 try 的 catch 体是否可能 rethrow（正常路径 soft 效果 release 而非 digest） */
+    tryRethrowCatch?: boolean;
+    /** 分支/循环体内深度（赋值记录 conditional 标记；inLoop 也计入） */
+    conditionalFlow?: number;
+    /** 函数/箭头体内（顶层绑定表只收顶层作用域） */
+    inFunction?: boolean;
+    /**
+     * 当前词法作用域的 `arguments` 绑定名（非箭头函数 prologue 里 `$arguments(...)`）。
+     * 箭头沿外层继承；无绑定（模块顶层 / 仅嵌套箭头引用）→ Identifier 分支折 $unknown()。
+     */
+    argsBinding?: string;
+};
+
+/**
+ * transpile 共享 AST 工具：形参名、match、fold、静态键、作用域收集、mutator receiver 扫描。
+ * 不依赖 stmt/expr 发射器（无环）。
+ */
+
+/**
+ * 编译期常量字符串折叠（require 说明符子集）：
+ * - StringLiteral
+ * - TemplateLiteral（无插值 / 插值全为可 ToString 字面量）
+ * - `+` 字符串拼接（至少一侧为可折叠字符串，另一侧为字符串或字面量）
+ * 不能折叠 → undefined（诚实动态，不假精确）。
+ */
+declare function foldStaticStringExpr(node: unknown): string | undefined;
+/** require(...) 第一个参数 → 可折叠说明符（StringLiteral / 模板 / 字面量拼接） */
+declare function foldRequireSpecArg(arg: unknown): string | undefined;
+
+/**
+ * 语句 / 块 / class 发射：transpileStatement、transpileBodyNode、transpileClass。
+ */
+
+declare function transpileBodyNode(node: Node, opts: TranspileOptions): string;
+
+/**
+ * 表达式发射：transpileExpression / transpileShortCircuitExpr。
+ */
+
+declare function transpileExpression(expr: Expression, opts?: TranspileOptions): string;
+
+/**
+ * B 路径 transpile：JS AST → 可在 Node 上执行的抽象值程序（源码字符串）。
+ * 运算符改为 $add/$sub/…；if 改为 $fork；for 改为 $for。
+ * 值类型是 Abs；副作用与模块仍由 host mock/注入。
+ *
+ * 实现按语句/表达式/模式拆在 transpile/*.ts；本文件是 re-export facade，
+ * 对外符号面保持不变（exec/index.ts `export * from "./transpile.ts"`）。
+ */
+
+declare function transpileSource(source: string, opts?: TranspileOptions): string;
+/** 运行时 import 行（body-fn 编译执行拼接用） */
+declare function runtimeImportOf(runtime: string): string;
+declare function transpileFile(file: File, opts?: TranspileOptions): string;
+/** 解析 + transpile */
+declare function transpile(source: string, opts?: TranspileOptions): string;
+
+/**
+ * 调用 Abs 一等函数（absFunction impl）或 mock apply。
+ * 供 B 路径 import 绑定包装：`(...args) => $call(absFn, args)`。
+ *
+ * 统一顺序：apply → body → relation → isRelFn（委托 applyAbsFn）。
+ * 行为对齐说明（与旧 $call 的差异，均属刻意）：
+ * 1. 带 body 的函数也进 call-budget（递归会 truncated 而非爆栈）
+ * 2. body 抛错 → never（applyAbsFn 内恢复，不返回中间值）
+ * 3. 无 impl 时 isRelFn 可走 E 路径（旧版恒 unknown）
+ */
+
+declare function $call(fn: Abs, args: Abs[], thisVal?: Abs): Abs;
+
+/**
+ * B class 规格表（无 call 依赖，避免循环）。
+ * Abs-eval registerClassDecl 与 transpile $class 共用。
+ */
+
+type BClassAccessor = {
+    get?: (thisVal: Abs) => Abs;
+    set?: (thisVal: Abs, v: Abs) => Abs;
+};
+type BClassSpec = {
+    name: string;
+    superName?: string;
+    ctor?: (thisVal: Abs, ...args: Abs[]) => Abs;
+    methods?: Record<string, (thisVal: Abs, ...args: Abs[]) => Abs>;
+    /** 实例方法形参展示名（AST 形参名；未调用方法槽 `shape.params` 用） */
+    methodParams?: Record<string, string[]>;
+    staticMethods?: Record<string, (...args: Abs[]) => Abs>;
+    /** 静态方法形参展示名 */
+    staticMethodParams?: Record<string, string[]>;
+    statics?: Record<string, Abs>;
+    /** 实例 get/set：get 无参返回 Abs；set 收到 (thisVal, v) 返回更新后的 thisVal */
+    accessors?: Record<string, BClassAccessor>;
+    /** 静态 get/set：挂在类构造器上，不在实例原型链 */
+    staticAccessors?: Record<string, BClassAccessor>;
+};
+declare function registerBClass(spec: BClassSpec): void;
+declare function getBClass(name: string): BClassSpec | undefined;
+declare function clearBClasses(): void;
+
+/**
+ * RegExp brand 执行面（leaf-ish）：从 class.ts 拆出，避免巨型文件。
+ */
+
+/**
+ * 语句级 RegExp 状态写回（test/exec）：执行并把 lastIndex 更新后的 brand
+ * 返回给 transpile 重绑（$reStateCall 与 $arrMutContainer 同模式）。
+ * 表达式位置不写回（$invoke 只读执行，调用方按 JS 语义先取值）。
+ */
+declare function $reStateCall(re: Abs, method: string, args: Abs[]): Abs;
+
+/**
+ * B 路径 class：brand 实例 + ctor/method 闭包 + 继承链。
+ * 方法内 this 由 transpile 改写为 thisVal 参数。
+ */
+
+/** 定义类 → 可 new 的 Abs（brand 标记；静态字段挂在 slots） */
+declare function $class(name: string, spec: Omit<BClassSpec, "name"> & {
+    extends?: string | Abs | unknown;
+}): 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（含 sum 成员 / 可能缺失）时用 default 并入非 undefined 部分 */
+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。非字面量 key → open + index join（不得写成字面槽 "?"） */
+declare function $setKey(o: Abs, key: Abs, value: Abs): Abs;
+
+/**
+ * B 路径调用点记录：transpile 把 `f(args)` 改成 $callNamed，
+ * 分析时可收集 call@ 所需的 AbsCallRecord。
+ * 成员缺失诊断见 member-diag.ts（共用，避免循环依赖）。
+ */
+
+type BCallRecord = {
+    fnName: string;
+    args: Abs[];
+    result: Abs;
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    threw?: boolean;
+};
+/** B 赋值记录（与 ast-records.ts AbsAssignRecord 同形；structuralAssignIssues 消费） */
+type BAbsAssignRecord = {
+    name: string;
+    prev: Abs | undefined;
+    next: Abs;
+    line?: number;
+    column?: number;
+    conditional?: boolean;
+};
+/** 返回先前 collector，便于嵌套调用 save/restore（禁止 finally 置 null 砸外层） */
+declare function setBAssignCollector(collector: ((r: BAbsAssignRecord) => void) | null): ((r: BAbsAssignRecord) => void) | null;
+/** 结构赋值记录（transpile 插桩调用；无收集器时 no-op） */
+declare function $assignRecord(name: string, prev: Abs | undefined, next: Abs, line: number, column: number, conditional: boolean): void;
+declare function setBBindingSink(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 noteBCallRecord(r: BCallRecord): void;
+declare function setBCallCollector(collector: ((r: BCallRecord) => void) | null): ((r: BCallRecord) => void) | null;
+declare function getBCallCollector(): ((r: BCallRecord) => void) | null;
+/**
+ * 按名调用并记录。
+ * loc: [line, column]（1-based line，0-based column，与 Babel 一致）
+ * argLocs: 与 args 对齐的实参字面量源位置（provenance；无 loc 用 null）
+ */
+declare const MAX_B_CALL_DEPTH = 64;
+/** 总调用上限：与 call-budget.MAX_TOTAL_CALLS 同阀（递归×循环×分支展开的
+ *  规模阀）。200k 在病态展开（lodash _baseFlatten）下 ~30s，20k 收口到
+ *  ~3s——截断 → opaque（更保守，zero-FP 安全）。 */
+declare const MAX_B_TOTAL_CALLS = 20000;
+/** 宿主入口（runTranspiled / callTranspiledExportFull）前重置 */
+declare function resetBCallBudget(): void;
+declare function $callNamed(name: string, fn: unknown, args: Abs[], loc?: [number, number], argLocs?: Array<[number, number] | null | undefined>): 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;
+
+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;
+/**
+ * 执行一段 B 路径程序，返回顶层 `export function` / `export const`。
+ */
+declare function runTranspiled(source: string, opts?: RunTranspiledOptions): Record<string, unknown>;
+/** B-path 回落事件（观测单一埋点；reason: unsupported:* = 能力边界，internal = B 自身缺陷） */
+type BPathFallback = {
+    reason: string;
+    message: string;
+    loc?: {
+        line: number;
+        column: number;
+    };
+};
+declare function setBPathFallbackCollector(collector: ((f: BPathFallback) => void) | null): void;
+/** 表达式级求值（scan 的 case 字面量实参等静态求值面）：编译单表达式经
+ *  B 运行时执行。bindings：表达式自由标识符 → Abs（调用方按绑定表注入）。
+ *  编译失败抛错（调用方按需 catch）。 */
+declare function evalExprAbs(expr: _babel_types.Expression, bindings?: Record<string, Abs>): Abs;
+/** 记录一次 B 回落（body-fn 等非 runTranspiled 入口共用） */
+declare function noteBPathFallback(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 的约束入口——B 侧路径条件收窄）。 */
+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;
+
+/**
+ * 转译器无法正确 lowering 的构造：抛此错误（替代静默降级注释）。
+ * 消费方（tryRunTranspiled / body-fn）捕获后记录并 fail-closed
+ * 结构化回落理由（unsupported:*）——能力知识单一事实源在转译点，
+ * 不再依赖带外的 isBPathCapable 清单。
+ */
+declare class NudoUnsupportedError extends Error {
+    readonly reason: string;
+    readonly loc?: {
+        line: number;
+        column: number;
+    };
+    constructor(reason: string, loc?: {
+        line: number;
+        column: number;
+    });
+}
+
+export { $add as $, type AbsModuleExports as A, $eq as B, $eqLoose as C, $fnVal as D, $for as E, $forInKeys as F, $forIter as G, $forOf as H, $fork as I, $ge as J, $gen as K, $get as L, $gt as M, $idx as N, $idxSet as O, $importMeta as P, $in as Q, type RunTranspiledOptions as R, $instanceof as S, $instanceofNonIdent as T, $invoke as U, $invokeSuper as V, $isBreakTo as W, $isForkExit as X, $join as Y, $le as Z, $len as _, $arguments as a, NudoReturn as a$, $lit as a0, $loopBreak as a1, $loopContinue as a2, $loopReturn as a3, $lt as a4, $mod as a5, $mul as a6, $ne as a7, $neLoose as a8, $neg as a9, $thisSet as aA, $throw as aB, $toNumber as aC, $tryCurrentMark as aD, $tryDetachSoftCatch as aE, $tryDigestSoftCatch as aF, $tryDiscardSoft as aG, $tryMark as aH, $tryOrphanSoft as aI, $tryPopMark as aJ, $tryReleaseSoftCatch as aK, $tryReleaseSoftOut as aL, $tryTakeSince as aM, $typeof as aN, $unknown as aO, $ushr as aP, $while as aQ, $whileSeq as aR, $yield as aS, type BAbsAssignRecord as aT, type BCallRecord as aU, type BClassSpec as aV, type BPathFallback as aW, DEFAULT_MAX_LOOP_ITERS as aX, MAX_B_CALL_DEPTH as aY, MAX_B_TOTAL_CALLS as aZ, NudoLoopSignal as a_, $new as aa, $not as ab, $nullishTest as ac, $obj as ad, $objAccessor as ae, $objRest as af, $optionalGet as ag, $optionalInvoke as ah, $orDefault as ai, $pow as aj, $pushLoopExit as ak, $rawThis as al, $reStateCall as am, $recordBinding as an, $regex as ao, $rethrowIfNudoReturn as ap, $set as aq, $setKey as ar, $shl as as, $shr as at, $spread as au, $staticInvoke as av, $sub as aw, $super as ax, $switch as ay, $thisGet as az, $arr as b, NudoThrow as b0, NudoUnsupportedError as b1, RUNTIME_IMPORT_RE as b2, type TranspileOptions as b3, type TranspiledCallResult as b4, asAbsVal as b5, bindImports as b6, bindingsOf as b7, callAtFunctionBoundary as b8, callTranspiledExport as b9, resetBCallBudget as bA, runTranspiled as bB, runTranspiledOptionsMemoKey as bC, runWithLoopExits as bD, runtimeImportOf as bE, setBAssignCollector as bF, setBBindingSink as bG, setBCallCollector as bH, setBPathFallbackCollector as bI, takeLoopExits as bJ, takeThrowExits as bK, transpile as bL, transpileBodyNode as bM, transpileExpression as bN, transpileFile as bO, transpileSource as bP, tryRunTranspiled as bQ, withExecPhi as bR, callTranspiledExportFull as ba, clearBClasses as bb, clearStaleTermPred as bc, collectAbsExports as bd, currentExecPhi as be, evalExprAbs as bf, fillTuple as bg, foldRequireSpecArg as bh, foldStaticStringExpr as bi, getBCallCollector as bj, getBClass as bk, isArrMutator as bl, isDefinitelyFalse as bm, isDefinitelyTrue as bn, isNudoBreak as bo, isNudoContinue as bp, isNudoReturn as bq, isNudoThrow as br, litTruth as bs, lookupObjAccessor as bt, namespaceNameOf as bu, noteBCallRecord as bv, noteBPathFallback as bw, pushLoopExit as bx, pushThrowExit as by, registerBClass as bz, $arrMutContainer as c, $arrRest as d, $arrWithHoles as e, $assignRecord as f, $async as g, $asyncReturn as h, $await as i, $bitand as j, $bitnot as k, $bitor as l, $bitxor as m, $call as n, $callNamed as o, $catchVal as p, $class as q, $classExpr as r, $collectionForEach as s, $concat as t, $copy as u, $del as v, $delRes as w, $div as x, $dynamicImport as y, $elems as z };