@nudojs/core 1.15.2 → 1.17.0

package/dist/exec.d.ts

@@ -1,5 +1,5 @@
-import { A as Abs, M as MayThrowEffect, b as Phi } from './run-DfloWX6i.js';
-export { W as $assignRecord, X as $call, Y as $callNamed, bI as $nodoPos, Z as $recordBinding, a5 as EvalAbsAssignRecord, a6 as EvalCallRecord, a7 as EvalFallback, g as EvalFallbackStats, a8 as EvalPosRecord, ab as MAX_EVAL_CALL_DEPTH, ac as MAX_EVAL_TOTAL_CALLS, ad as RUNTIME_IMPORT_RE, V as RunTranspiledOptions, af as TranspiledCallResult, at as bindingsOf, aw as callTranspiledExport, ax as callTranspiledExportApply, ay as callTranspiledExportFull, l as clearPureCallMemo, m as clearPureMemo, n as enterEvalCallBudgetSession, aD as evalExprAbs, p as exitEvalCallBudgetSession, v as getEvalCallBudgetState, aG as getEvalCallCollector, w as getEvalFallbackStats, bJ as getPosCollector, aO as isAbsVal, aQ as isCjsMainRun, b5 as noteEvalCallRecord, b6 as noteEvalFallback, bn as resetEvalCallBudget, H as resetEvalFallbackStats, bK as routeApplyThrows, bo as runTranspiled, bp as runTranspiledOptionsMemoKey, bq as setEvalAssignCollector, br as setEvalBindingSink, bs as setEvalCallCollector, bt as setEvalFallbackCollector, bv as setPosCollector, bF as tryRunTranspiled, O as withEvalBudgetOverride } from './run-DfloWX6i.js';
+import { A as Abs, M as MayThrowEffect, b as Phi } from './run-tV2J7PNI.js';
+export { V as $assignRecord, W as $call, X as $callNamed, bG as $nodoPos, Y as $recordBinding, a4 as EvalAbsAssignRecord, a5 as EvalCallRecord, a6 as EvalFallback, g as EvalFallbackStats, a7 as EvalPosRecord, aa as MAX_EVAL_CALL_DEPTH, ab as MAX_EVAL_TOTAL_CALLS, R as RunTranspiledOptions, ad as TranspiledCallResult, ar as bindingsOf, au as callTranspiledExport, av as callTranspiledExportApply, aw as callTranspiledExportFull, l as clearPureCallMemo, m as clearPureMemo, n as enterEvalCallBudgetSession, aB as evalExprAbs, p as exitEvalCallBudgetSession, v as getEvalCallBudgetState, aE as getEvalCallCollector, w as getEvalFallbackStats, bH as getPosCollector, aM as isAbsVal, aO as isCjsMainRun, b3 as noteEvalCallRecord, b4 as noteEvalFallback, bl as resetEvalCallBudget, H as resetEvalFallbackStats, bI as routeApplyThrows, bm as runTranspiled, bn as runTranspiledOptionsMemoKey, bo as setEvalAssignCollector, bp as setEvalBindingSink, bq as setEvalCallCollector, br as setEvalFallbackCollector, bt as setPosCollector, bD as tryRunTranspiled, O as withEvalBudgetOverride } from './run-tV2J7PNI.js';
 import { Node, Expression, File } from '@babel/types';
 
 /**
@@ -23,6 +23,19 @@ declare function isNudoThrow(e: unknown): e is NudoThrow;
 /**
  * 求值引擎运行时共享状态：phi、就地写、字面量 Abs、真值、循环信号。
  * 叶子模块——不依赖 runtime 其它文件（tuple/obj 字面量就地构造，避免 state↔containers 环）。
+ *
+ * Invariants:
+ * - Bug 213：宿主 / 命名空间对象（Math / JSON / Reflect）的自有属性投影按
+ *   **getOwnPropertyNames**（全部自有字符串键）而非 Object.entries（只取可
+ *   枚举键）——原生这些对象的自有属性几乎全不可枚举，按可枚举投影会把整个
+ *   自有面丢掉（gOPN / ownKeys / hasOwn / gOPD 全折 0）；逐键记 enumerable /
+ *   writable / configurable 标志，不可枚举键仍不进枚举面。
+ * - Bug 210：enforceProxyGetInvariant 是 Proxy [[Get]] 规范不变量的单一实现
+ *   （靶上自有属性不可配置且不可写时，get 陷阱须返回其实际值）；
+ *   proxyTargetInnerObj 归一化「靶 → 内层 obj Abs」（不变性侧表与槽表都挂
+ *   在内层 obj 上——brand 包装的靶走内层）。
+ *   [[OwnPropertyKeys]] 不变量（重复名 / 漏键 / 多余键）在
+ *   builtins/object/descriptor.ts（enforceProxyOwnKeysInvariant）。
  */
 
 /** 调用方已直接改 shape 时的 term/pred 清理 */
@@ -39,6 +52,8 @@ declare function withAssumePremises<T>(p: Phi, body: () => T): T;
  * extractParamNames 回退口径一致）；带真实参数名走 $fnVal（transpile 侧）。
  */
 declare function asAbsVal(v: unknown): Abs;
+/** transpile 生成代码用：给宿主函数打种类戳（Bug 325） */
+declare function $fnKindStamp(fn: unknown, kind: string): void;
 /** transpile 侧收形入口（instanceof RHS 值等）：host 裸值 / Abs → Abs。
  *  `$` 前缀是运行时绑定表（runtimeArgNames）的注入约定。 */
 declare function $absVal(v: unknown): Abs;
@@ -70,6 +85,8 @@ declare function $fnVal(params: string[], impl: (...args: Abs[]) => Abs, opts?:
     effectFree?: boolean;
     closed?: boolean;
     kind?: string;
+    fnKind?: "function" | "async" | "generator" | "async-generator";
+    optionalParams?: boolean[];
 }): Abs;
 /**
  * 宿主 this → Abs：函数体 prologue 用它承接 call/apply/bind 传入的 thisArg。
@@ -78,8 +95,18 @@ declare function $fnVal(params: string[], impl: (...args: Abs[]) => Abs, opts?:
  * globalThis——归一到 $lit(undefined)（strict 模块语义下的 this）。
  */
 declare function $rawThis(v: unknown): Abs;
+/** const 绑定再赋值（Assignment to constant variable）→ hard TypeError */
+declare function $throwConstAssign(): never;
+/**
+ * 自由 `arguments` 读（模块顶层 / 无任何外层函数绑定）：非宿主全局，
+ * 原生 unresolvable reference → hard ReferenceError（ESM 无 arguments
+ * 全局；`typeof arguments` 豁免由 transpile 折 "undefined" 不走此处）。
+ */
+declare function $throwFreeArguments(): never;
 /** `new.target` 读：栈顶类值；普通调用面已清空 → undefined 字面量 */
 declare function $newTarget(): Abs;
+/** 生成代码可用的真值判定（undefined = 无法判定）；与 litTruth 同口径 */
+declare function $litTruth(a: Abs): boolean | undefined;
 /** 字面量 → Abs（transpile 侧数字/字符串/布尔/null/undefined） */
 declare function $lit(v: unknown): Abs;
 /** JS 真值：字面量按 Boolean(v)；对象形恒真；不可判 → undefined */
@@ -128,6 +155,14 @@ declare class NudoReturn extends Error {
 declare function isNudoReturn(e: unknown): e is NudoReturn;
 /** transpile `return x` inside for/while → `$loopReturn(x)` */
 declare function $loopReturn(v: Abs): never;
+/**
+ * transpile 函数体边界吸收器：`try { body } catch (e) { return $catchReturn(e); }`
+ * —— 函数体内 $loopReturn 早退（循环 / if 臂）在函数自身边界收成返回值，
+ * 转译模块对裸宿主调用（e2e 真实 .mjs 导入 / 模块顶层互调）自包含；
+ * 其余异常（NudoThrow / 原生错误）原样 rethrow。仅在发射体含 $loopReturn
+ * 时由 transpile 侧包裹。
+ */
+declare function $catchReturn(e: unknown): Abs;
 declare class NudoLoopSignal extends Error {
     readonly kind: "break" | "continue";
     readonly label: string | undefined;
@@ -157,6 +192,23 @@ 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;
+/**
+ * issue #165：局部量引理锚定。`@nudo:assume <name> <= <name>` 从仅形参扩展到
+ * 形参 ∪ 函数体顶层 const/let/var 局部绑定，SSA 语义：引理作用于绑定值，
+ * 从定义点到作用域尾。transpile 在局部量 init 处包裹
+ * `$assumeAnchor(init, name)`——把 init 结果的 term α-改名为 var(name)，
+ * 使后续读点与 assume 前提里的 var(name) 同项，arithmetic 的同名相关性
+ * 折叠（le 折除法界等）才能命中。shape/conf 不动，嵌套 shape 内 term
+ * 不改（保守：根 term 已建立项身份，深改无消费方）。
+ *
+ * 为何需要当前帧前提护栏：assume 前提不随调用链继承——callee 帧一律见空
+ * （callAtFunctionBoundary 以 withAssumePremises(pTrue, …) 包裹 callee 体）。
+ * 锚定落在错帧（前提 pTrue，或 and 原子中没有任何 le 原子在 a/b 侧以
+ * var(name) 出现——本帧没有这条引理）时，改名只会凭空捏造约束身份 →
+ * 原样 no-op。这也封死 #123 式同名 term 碰撞：callee 恰有同名局部时，
+ * caller 帧前提已被清空，caller 引理不会错投到 callee 的同名绑定上。
+ */
+declare function $assumeAnchor(v: unknown, name: string): unknown;
 declare function $bitand(a: Abs, b: Abs): Abs;
 declare function $bitor(a: Abs, b: Abs): Abs;
 declare function $bitxor(a: Abs, b: Abs): Abs;
@@ -188,6 +240,17 @@ declare function $join(a: Abs, b: Abs): Abs;
 
 /**
  * 访问器（get/set）侧表、in / instanceof / delete 路由。
+ *
+ * Bug 149：符号键（Symbol.iterator 等）按**宿主身份**反查 "@@X" 内部槽键
+ * 寻址（与读写面同口径），Proxy has 陷阱收到**真 symbol**（规范
+ * PropertyKey）——不再在「键不可判」处提前 return（陷阱此前完全不派发）。
+ * Bug 230：delete 运算符路径（$delRes）的 Proxy [[Delete]] 规范不变量——
+ * deleteProperty 陷阱返 true 时，若靶上该键是不可配置自有属性 ⇒ 原生定抛
+ * TypeError（此前直接返 true，假绿；Reflect 臂已由 S9 接线）。
+ * Bug 194：`delete X.prototype.m` —— 类方法在方法注册表（spec.methods）里，
+ * 原型对象上无该方法的槽 ⇒ 只删槽不留痕（读/调用/in 三面继续命中）。
+ * $del 在 `.prototype` brand 臂按 owner 名通知注册表侧移除（S8 的
+ * deleteProtoMethod 钩子）；delete 返回值恒 true（原生同）。
  */
 
 /** 计算键访问器注册（`{ get [expr]() {} }`）：键为 Abs，ToPropertyKey 后注册。
@@ -209,12 +272,19 @@ declare function $in(key: Abs, o: Abs): Abs;
 declare function $instanceof(left: Abs, rightName: string, rightVal?: Abs): Abs;
 /** instanceof 右操作数非标识符（表达式/成员路径）：RHS 值传入时先做原生
  *  非对象校验（definite / may TypeError）；构造器值未知 → 抽象 boolean */
-declare function $instanceofNonIdent(left: Abs, right?: Abs): Abs;
-/** ClassExpression 值：构造器函数形状，不得折成精确 undefined */
-declare function $classExpr(): Abs;
+declare function $instanceofNonIdent(_left: Abs, right?: Abs): Abs;
+/**
+ * ClassExpression 值：构造器函数形状，不得折成精确 undefined。
+ *
+ * Bug 133：name —— **NamedEvaluation 名**（`const K = class {}` → "K"）。
+ * 空类体走本快路径（fn 形状），类名落在 fn 形状的 name 位（$get(fn,"name")
+ * 读 shape.name）——无名类不传（原生名为空串）。
+ */
+declare function $classExpr(name?: string): Abs;
 /**
  * `delete obj[key]` 的结果判定（只读，不写回）。
  * frozen/sealed 或 configurable:false 键 → false；preventExtensions 可删；
+ * 数组 length 恒不可配置 → strict 定抛 TypeError（Bug 230）；
  * closed 目标恒 true（其余 non-configurable 形态不建模）；
  * nullish 接收者原生 definite TypeError（ToObject(null) 抛）→ hard NudoThrow；
  * 非 nullish prim 接收者原生不抛（装箱临时对象上 delete 恒 true，strict 亦然）
@@ -224,7 +294,8 @@ declare function $delRes(o: Abs, _key: Abs): Abs;
 /**
  * `delete obj[key]` 的写入（不可变更新）：返回删键后的新容器。
  * 闭对象删自有槽；tuple 规范下标置 undefined（对齐原生空洞读值）；
- * 抽象 arr 元素并入 undefined；无法表达的形态原样返回。
+ * 抽象 arr 元素并入 undefined；数组 length 不可配置 → strict 定抛
+ * TypeError（Bug 230）；无法表达的形态原样返回。
  */
 declare function $del(o: Abs, key: Abs): Abs;
 
@@ -233,6 +304,14 @@ declare function $del(o: Abs, key: Abs): Abs;
  * 下沉原因：objects.ts 的 joinObjects 需感知访问器（join 不迁移侧表会丢
  * getter 读域），而 members.ts 依赖 objects.ts；表放无运行时依赖的叶子上
  * 才能被两层共用而不成环。in / instanceof / delete 路由仍在 members.ts。
+ *
+ * 不变量：
+ * - 访问器**不住在 shape 槽里**：transpile 只落一个 `$lit(void 0)` 占位槽
+ *   （保键存在性：'x' in o / keys / assign 拷贝目标），真 getter 住本侧表；
+ * - 读通道（$get/$set）先查侧表再回落槽值 ⇒ `o.ab` 读得对；
+ * - **投影通道**（formatShape / denoteGuard / absToConstraint / 契约证明）
+ *   必须先经 accessorReadDomain 取读域，否则把占位槽渲染成 exact
+ *   `undefined`——一个自信的错值（比真值更窄且自相矛盾，Bug 191）。
  */
 
 /** 注册对象字面量访问器（transpile 调用；返回原 obj 以便链式包裹） */
@@ -248,17 +327,12 @@ declare function lookupObjAccessor(o: Abs, key: string): {
  */
 declare const DEFAULT_MAX_LOOP_ITERS = 8;
 
-declare function $fork(test: Abs, consequent: () => Abs, alternate?: () => Abs): Abs;
-
 /**
- * for 的惰性展开：生成器只负责「按上限吐状态」。
- * 抽象条件无法诚实终止——消费者必须自带 maxIters。
+ * 控制流：loop/try 退出栈、$fork/$for/$whileSeq、$throw。
  */
-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>;
+
+declare function $fork(test: Abs, consequent: () => Abs, alternate?: () => Abs): Abs;
+
 /**
  * 有界 for：unroll ≤ maxIters，每步「可能退出」的态 join；
  * 相邻态 leq 视为不动点提前停。
@@ -268,12 +342,10 @@ declare function $for(init: Abs, test: (s: Abs) => Abs, step: (s: Abs) => Abs, b
     unpack?: (s: Abs) => void;
     /** 标签循环（`outer: for …`）：仅吸收同标签 break/continue 信号 */
     label?: string;
+    /** 循环变量的最新写（Bug 228）：continue 臂取「体退出瞬间的循环变量值」
+     *  ——转译侧在体的 finally 里写回共享槽；缺省（未插桩）时以 state 近似。 */
+    loopVar?: () => 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 变量赋值。
  * 提供 pack/unpack 时，抽象条件的可能出口会 join 回绑定（P0 健全）；
@@ -287,12 +359,6 @@ declare function $whileSeq(test: () => Abs, body: () => void, maxIters?: number,
     /** 标签循环：仅吸收同标签 break/continue 信号 */
     label?: string;
 }): void;
-/**
- * switch：具体 disc 选中匹配 case；抽象 disc 并所有分支。
- * 抽象路径与 $fork 同构：集合 side-table 按臂 overlay，共享 body 只跑一次；
- * 臂内 NudoReturn/NudoThrow 不冒泡污染兄弟臂。
- * **无 default 时必须隐式 fall-through 臂（undef）**，否则无匹配路径被丢掉（P0-2）。
- */
 declare function $switch(disc: Abs, cases: Array<{
     test: Abs;
     run: () => Abs;
@@ -305,7 +371,15 @@ declare function $throw(v: Abs): never;
  * 不得污染 join 后的 continue 绑定。
  */
 declare function $isForkExit(e: unknown): boolean;
-/** catch 参数：从 NudoThrow 取出 Abs；宿主 Error 补 name/message；否则 unknown */
+/**
+ * catch 参数：从 NudoThrow 取出 Abs；宿主 Error 补 name/message；否则 unknown。
+ *
+ * Bug 211：**控制流信号（break / continue）不是异常**——原生里 `break` 是
+ * 控制流完成值，根本到不了 catch 处理器（catch 体不跑、循环照常退出）。
+ * 引擎的循环信号是 Error 子类 ⇒ 会被 catch 接住；此前 catch 体把信号「吃掉」
+ * （副作用照跑、循环还不退出）。修法：控制流信号在此**重抛** ⇒ catch 体不执行、
+ * 信号透传到循环捕获点（catch 体只吞真异常）。
+ */
 declare function $catchVal(e: unknown): Abs;
 
 /**
@@ -315,16 +389,32 @@ declare function $catchVal(e: unknown): Abs;
  * - $copy 是 fork/switch/循环 pack 的状态分离机制：所有可挂侧表的形状
  *   （extState/propFlags/accessorTable/nullProto/matchIter）必须随快照
  *   迁移，副本丢失侧表 = 臂内写不再硬抛 / 延迟异常静默丢弃。
+ * - fn 形状同样是可扩展对象：expando 槽面（含 optionalParams/ctor/类型
+ *   侧信息）逐臂独立复制（共享槽面会让兄弟臂写互相覆盖）；impl 身份、
+ *   槽面写权限侧表（objects.ts 的 userFnSlotOwners）、null-proto 标记与
+ *   新鲜实例 id 随副本迁移（侧表丢失 ⇒ `__proto__` 读翻转 / `===` 退化）。
  * - $spread 原生语义会**调用**源对象 getter 并把结果拷为数据槽——必须
  *   用 getter 求值后的副本（accessorTable 求值，抛/失败折 unknown）。
+ * - $objRest 同理：原生 CopyDataProperties 对保留键发 Get ⇒ getter 必须
+ *   被调用（副作用发生），rest 槽落 getter 的**返回值**（非占位 undefined）。
  */
 
 /**
  * 深拷贝可变容器（fork/switch 快照与循环 pack 用）。
  * 容器写就地进行后（引用语义），分析分支/迭代的状态分离必须靠拷贝——
  * 浅引用快照会让臂间/迭代间互相污染。
+ *
+ * `memo` 是**身份图**：同一原始 Abs 在同一次快照里必须映射到同一个副本。
+ * - 循环引用（`o.self = o`）靠「先占位、后填空」终止递归；
+ * - 共享子图（DAG）不再指数复制；
+ * - 同一次快照/调用边界里的多个绑定保持别名关系（memo 必须由调用方共享；
+ *   `$copy(a)` 单参调用只为兼容旧行为，等价于每次新建 memo）。
+ *
+ * 注意：这只能保证**被复制集合内部**的身份关系。若 `b` 是 `a` 的别名但
+ * 不在同一次快照的绑定集合里，fork/pack 仍会断开 `a`/`b`；调用方必须把
+ * 别名伙伴一起纳入复制集合（见 transpile 的 aliasGroups）。
  */
-declare function $copy(a: Abs): Abs;
+declare function $copy(a: Abs, memo?: WeakMap<object, Abs>): Abs;
 /** 对象字面量 → Abs obj（槽位写走 setSlot，`__proto__` 不踩宿主 setter） */
 declare function $obj(slots: Record<string, Abs>): Abs;
 /**
@@ -338,9 +428,10 @@ declare function $setProto(o: Abs, proto: Abs): Abs;
 declare function $spread(a: Abs, b: Abs): Abs;
 /**
  * 解构 rest：`const { a, ...rest } = o` → rest = o 去掉 named keys。
+ * 排除集可含**动态计算键**（Abs）——原生按求值后的键排除（Bug 160）。
  * closed obj：剩余槽 closed；open / optional 键：rest 仍 open（可能有未知键）。
  */
-declare function $objRest(o: Abs, keys: string[]): Abs;
+declare function $objRest(o: Abs, keys: Array<string | Abs>): Abs;
 
 /**
  * 元组/数组构造与宽化。
@@ -392,6 +483,9 @@ declare function $restBind(list: ArrayLike<unknown>, namedCount: number): Abs;
  *   抽象 → may（空接收者同样先校验）；values 实参不校验（原生存储不转换）。
  * - mutator 降 arr（splice 等）的元素域 = 全部观测元素 join——不并入
  *   OOB undefined（issue #156 元素域约定）。
+ * - 完整性门（Bug 223）：frozen 任何 mutator 抛；sealed 的**结构性扩展**
+ *   （push/unshift/splice）与**删除既有自有属性**（pop/shift 命中自有元素）
+ *   抛 TypeError；空数组 / 空洞位 / preventExtensions（nonext）不抛。
  */
 
 declare function isArrMutator(name: string): boolean;
@@ -421,6 +515,10 @@ declare function $arrMutContainer(arr: Abs, method: string, args: Abs[]): Abs;
  *   （issue #175：否则 xs[0].length - xs[1].length 假折 0）。
  * - abstractLen memo 只对**绑定接收者**合法（跨读同 term sound）；
  *   lenVarSeq 单调递增，len#N term 全局唯一。
+ * - Bug 209：Proxy **set 陷阱**返回值按规范 ToBoolean 判定——falsy（0 / "" /
+ *   null / undefined / false）→ strict TypeError（只认字面量 false 会漏）。
+ * - Bug 197：下标写查 defineProperty 的 writable:false → strict TypeError
+ *   （此前下标臂只查 frozen / sealed，flags 面没查 → 写穿无声）。
  */
 
 /** 下标读 a[i]；规范数组下标走精确投影，确定非下标键 → undefined，否则并所有元素；string[i] → 单字符 */
@@ -444,20 +542,64 @@ declare function $len(a: Abs, opts?: {
  *   内层空 obj，原型链 @@iterator 不在内层建模）。
  * - 生成器/模板标签/matchAll 迭代物挂对象侧表：迭代 = 消费（从当前位
  *   取剩余），体内延迟异常在消费点重放（不得静默截断成前缀，Bug 34）。
+ * - async generator（仅 @@asyncIterator 槽的**生成器对象**，Bug 141）：
+ *   for-await 的元素域走**元素侧表**（与同步 generator 同口径：元素取
+ *   侧表剩余条目，长度亦由侧表给出）——不得落 asyncOnly 的 unknown 快
+ *   路径（元素域精度回退）；非生成器的仅异步可迭代对象元素域不可静态刻
+ *   画 → 仍折 unknown。
  * - unbounded（长度未知）单代表迭代只跑一次：0 次/出口臂由 fork-arm +
  *   snapExit join 承接；break/continue 打断代表体 → widen.markInterrupted
  *   （完整迭代效应不可观测，累加器域整体宽化）。
+ * - Bug 195：标签模板对象是**冻结的数组 exotic**（原生 GetTemplateObject →
+ *   CreateArrayFromList + SetIntegrityLevel(frozen)）⇒ 元槽（length / raw /
+ *   @@iterator）**非枚举**、对象**冻结**（extState）、JSON 走**数组序列化面**
+ *   （数组视图标注）。未冻结的普通 obj 不得被误标。
+ * - Bug 198：Map/Set 的条目遍历（forEach / for-of）必须是**接收者的 live
+ *   视图**——回调里的增删删改对迭代可见（live 视图按访问序取，条目身份去重）。
+ * - Bug 198（S20）：live 集合 / 数组迭代器**不登记静态元素侧表**（静态表是
+ *   创建期拷贝 ⇒ 元素面与长度冻结在创建时刻）⇒ 迭代物判定（$arrRest 的
+ *   「侧表迭代物」门、$yieldStarElems 的长度可知性）必须**同口径**认
+ *   **消费视图**（registerGenDrain）——只查静态侧表会把 live 迭代物误判成
+ *   「非迭代物」（rest 解构退 unknown）。
+ * - Bug 199：非正常出口（break / return / throw / label break）与**解构模式
+ *   填满而迭代器未耗尽**必须 IteratorClose（调用户迭代器的 return()）；continue
+ *   与自然耗尽**不**调；无 return 槽**不**凭空抛（抽象面不判定）。
+ * - Bug 200：for..in 遍历 brand 实例须**沿原型链**枚举可枚举键（原型上的
+ *   class 方法非可枚举 ⇒ 不出现）。
+ * - Bug 215：for-of 的**具体出口**（无快照 join）也须实施 @nudo:invariant 公理
+ *   （无公理时不取绑定包——零行为变化）。
  */
 
 /** 数组 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;
-/** 数组解构模式接收者守卫：原生数组解构 = GetIterator + IteratorNext，
- *  非可迭代接收者抛 TypeError。emitDestructure 的 ArrayPattern 分支在逐项
- *  $idx / $arrRest 投影前调用；值域投影不变（字符串/元组等可迭代接收者
- *  不受影响）。 */
-declare function $iterCheck(a: unknown): void;
+/**
+ * 用户 iterable 的**迭代序**元素读取器（`$iterCheck` 返回值）：
+ * - `get(i)`：第 i 个元素（迭代序）；越界 = 迭代已 done → exact undefined；
+ *   列表被截断（truncated）→ unknown（sound）。
+ * - `rest(i)`：从第 i 项起的剩余元素（原生 rest 语义：迭代到 done 为止）；
+ *   截断 → unknown（剩余长度不可知）。
+ */
+interface UserIterReader {
+    get(i: number): Abs;
+    rest(i: number): Abs;
+}
+/**
+ * 数组解构模式接收者守卫 + **用户 iterable 迭代序元素读取器**。
+ *
+ * 两件事（同一调用，避免生成码再判一次接收者形态）：
+ * ①守卫：原生数组解构 = GetIterator + IteratorNext，非可迭代接收者抛
+ *   TypeError（definite）；抽象接收者记 may-throw。
+ * ②返回用户 iterable（对象带自有 `@@iterator` 槽、引擎无其元素模型）的
+ *   迭代序元素读取器；**非**用户 iterable → null ⇒ 调用方走既有 `$idx` /
+ *   `$arrRest` 快速路径（tuple / 数组 / 字符串 / Set / Map / 生成器 /
+ *   `$tpl` / 数组迭代器…逐字不变）。
+ *
+ * `maxElements`：本次最多取几个元素（原生按需取：模式有 n 个位置就取 n 个，
+ * 空位也消耗一个）；缺省 / 负数 = 取到 done（受 USER_ITER_MAX_STEPS 上界约束）。
+ */
+declare function $iterCheck(a: unknown, maxElements?: number): UserIterReader | null;
 /** 元素列表（tuple 展开；arr 抽象；C1 Set/Map 逐条目；matchAll 迭代器逐匹配项；
  *  字符串按 code points）。Map 迭代语义是 entry `[key, value]` 元组，不是裸 value。
  *  消费前先过可迭代性守卫（Bug 6）：prim 字面量接收者 → 原生 definite
@@ -469,18 +611,28 @@ declare function $elems(a: Abs): Abs[];
  *  为 cooked 字符串（无效转义序列时 cooked 是 undefined，原生实测）、
  *  length 精确、.raw 为 raw 字符串数组；@@iterator 槽给函数形状
  * （`[...s]` / `for..of` / `Symbol.iterator in s` 均按可迭代面判定，
- *  不得把冻结数组误判 definite 不可迭代）。 */
-declare function $tpl(cooked: Array<string | undefined>, raw: string[]): Abs;
-/**
- * for-of：对 iterable 每个元素跑 body；有界展开。
- * body(item, i) 可返回 void；状态由外部 JS 变量承接。
- * - 具体空 tuple：体 0 次（不得用 `length || maxIters` 展开成 maxIters）
- * - 抽象 arr / 未知长度：0..maxIters 出口与 pack 状态 join
- */
-/**
- * for-in 键序列：原生顺序为整数键升序 → 其余键按插入序；
- * 数组 hole 槽不出键（读值为 undefined 但不可枚举）。仅自有可枚举键。
+ *  不得把冻结数组误判 definite 不可迭代）。
+ *
+ * Bug 195：原生 GetTemplateObject = `CreateArrayFromList` + `SetIntegrityLevel(frozen)`
+ * ⇒ 模板对象是**冻结的数组 exotic**：
+ * - `length` / `raw` / `@@iterator` 是**非枚举**自有属性（原生三者全非枚举；
+ *   `Object.keys(s)` 只有下标 "0".."n-1"）——此前平铺为可枚举槽 ⇒ Object.keys
+ *   折出 "0,1,length,raw,@@iterator"（错值）。
+ * - `Object.isFrozen(s)` / `Object.isFrozen(s.raw)` 均为 true（原生冻结）——
+ *   此前 false。冻结走 extState 侧表（`Object.isFrozen` 的判定源）。
+ * - `JSON.stringify(s)` 走**数组序列化**（原生 `["a","b"]`）——此前走 obj 面
+ *   折 `{"0":"a",...}`。数组视图标注（markMatchArrayView）复用 RegExp exec
+ *   结果同款机制（json.ts 消费，不改 json.ts）。
+ *
+ * **未建模（越界，需 member.ts / builtins/array.ts）**：
+ * - `Array.isArray(s)` 原生 **true**（模板对象是数组 exotic）——引擎 isArray
+ *   只认 arr/tuple 形状 ⇒ 仍折 false（需 builtins/array.ts 查模板对象标注）。
+ * - 数组原型方法（`s.join` / `s.map` / `s.slice` / `s.indexOf` / `s.concat`）
+ *   原生可调（模板对象继承 Array.prototype）——引擎 obj 接收者的数组方法
+ *   派发面只认 tuple/arr 形状 ⇒ 此前折**确定抛 TypeError**（假抛）。
+ *   需 member.ts 的 $get 数组方法臂认模板对象（按元素侧表投影）。
  */
+declare function $tpl(cooked: Array<string | undefined>, raw: string[]): Abs;
 declare function $forInKeys(o: Abs): Abs;
 declare function $forOf(iterable: Abs, body: (item: Abs, index: Abs) => void, maxIters?: number, opts?: {
     pack?: () => Abs;
@@ -489,7 +641,9 @@ declare function $forOf(iterable: Abs, body: (item: Abs, index: Abs) => void, ma
     label?: string;
     /** for await：接收者按 GetIterator(hint=async) 校验（@@asyncIterator 槽
      *  即全量）；仅异步可迭代（无 @@iterator 槽）的接收者不折同步槽位投影，
-     *  元素取抽象 unknown（原生由 next() 链驱动）。 */
+     *  元素取抽象 unknown（原生由 next() 链驱动）——**async generator 例外**
+     *  （Bug 141）：它是生成器对象，元素域走元素侧表（与同步 generator
+     *  同口径）。 */
     forAwait?: boolean;
     /** for-in（Bug 98）：接收者重查 thunk——快照键进体前重查在场，体内
      *  delete 的未访问键跳过该迭代（与原生 EnumerateObjectProperties 的
@@ -501,6 +655,11 @@ declare function $forOf(iterable: Abs, body: (item: Abs, index: Abs) => void, ma
  * Map/Set forEach：条目表逐条调用回调（value, key, recv）。
  * 回调是 求值引擎 JS 函数（transpile 内联箭头）直接调用；Abs fn 走 $call。
  * 回调返回值丢弃；forEach 表达式值恒 undefined。
+ *
+ * Bug 198：**live 视图**——原生 forEach 持条目指针：迭代期间新增的条目被
+ * 访问、删除的条目被跳过（`m.forEach(v => { out.push(k); m.set("b",2) })`
+ * 原生 "a,b"，引擎快照口径只有 "a"）。表不干净（shadow / maybeAbsent）⇒
+ * 无 live 视图 ⇒ 沿用快照口径。
  */
 declare function $collectionForEach(recv: Abs, cb: unknown): Abs | undefined;
 
@@ -517,6 +676,51 @@ declare function $collectionForEach(recv: Abs, cb: unknown): Abs | undefined;
  * - 闭 shape 字面量 key miss → 精确 undefined（键确定不存在）；open
  *   shape / 抽象键 → 并 unknown（键可能存在）；已知原型访问器名槽面
  *   未建模 → 诚实 unknown（不得 wrong-exact undefined）。
+ * - Bug 149：符号投影键（"[Symbol.X]" → "@@X"）在 **Proxy 陷阱边界**还原成
+ *   真 symbol（规范 PropertyKey）；字面量串键 "@@X" 不带标记，仍是字符串键。
+ * - Bug 218：prim（number/boolean/bigint/symbol）读**确定不存在**的成员 →
+ *   undefined 字面量（原生语义），不是 unknown——unknown 接收者不记
+ *   may-throw，会让后续读该值的 TypeError 丢失（L2 门禁假绿）。
+ * - Bug 219：symbol prim 的 toString/toLocaleString/valueOf 走
+ *   **Symbol.prototype 自己的面**（toString/valueOf 带 brand check——
+ *   借用调用非 symbol 接收者定抛 TypeError），不落 Object.prototype 泛型版。
+ * - Bug 206/225：类值写面的两个原生「不可写」——`A.prototype = v` 与
+ *   getter-only 静态访问器的写，都定抛 strict TypeError（例外：引擎内部
+ *   defineProperty 对原型的就地改写回装）。
+ * - Bug 234：类值的 `constructor` = 内建 Function（原生继承自
+ *   Function.prototype），不是「以类名命名的内建构造器」。
+ * - Bug 235：Proxy 无 get 陷阱时转发 `target.[[Get]](key, Receiver)`——
+ *   Receiver 必须是 proxy 自己（靶上 getter 的 this = receiver，不是靶）。
+ * - Bug 210：Proxy **get 陷阱**返回值过 [[Get]] 规范不变量（state.ts 的
+ *   enforceProxyGetInvariant）——靶上自有属性不可配置且不可写时，陷阱值
+ *   须 SameValue 靶值，否则原生定抛 TypeError（此前直接返陷阱值，假绿）。
+ * - Bug 209：Proxy **set 陷阱**返回值按规范 ToBoolean 判定——falsy（0 / "" /
+ *   null / undefined / false）→ strict TypeError（只认字面量 false 会漏）。
+ * - Bug 197：[[Set]] 写门——receiver **无自有该键**时沿 [[Prototype]] 链
+ *   上溯（OrdinarySet）：访问器（无 setter）→ strict TypeError；带 setter
+ *   → 派发 setter；数据属性 writable:false / frozen 原型 → strict
+ *   TypeError；链上无人持该键 → receiver 建自有属性。fn 臂 / 静态类值臂 /
+ *   数组下标臂另查 defineProperty 的 writable:false（见 proto-set.ts）。
+ *   **类实例面**同走该门（原型 = `A.prototype`，proto-set.ts 经
+ *   protoOfRecv 解析类注册表）——此前类实例未登记 protoTable ⇒ 门恒 allow
+ *   ⇒ 原型上动态装的只读属性 / getter-only 被静默写穿。
+ * - Bug 223/231：数组 length 写门——域判定走 ToNumber（具体非数值
+ *   undefined / {} / "abc" 定抛 RangeError，Symbol 抛 TypeError）；sealed
+ *   数组 length **截断**写要删不可配置元素 → strict TypeError（增长合法；
+ *   preventExtensions 不冻结元素 → 截断不抛）。见 array-length.ts。
+ * - Bug 198（S20）：内建 brand 实例上的 `@@iterator` 读值 = **原型上同一个
+ *   函数对象**（原生 m[Symbol.iterator] === Map.prototype[Symbol.iterator]）
+ *   ⇒ 走符号成员表（builtinSymbolMemberAbs），不得给 no-op fn——no-op fn 被
+ *   调用折 <abs:never>（自信的错值：原生返回集合迭代器）。Map/Set 的该成员
+ *   产出 **live 视图**集合迭代器（collectionIteratorFor），投影口径同原生：
+ *   Map → [k,v] 元组（entries），Set → 元素本身（values，非 [el,el]）。
+ * - Bug 291：fn 臂的**不变性写门**与 obj 臂同款——frozen 全写 strict
+ *   TypeError；sealed/nonext 新键 TypeError（函数亦是不可扩展对象）。
+ * - Bug 315：本模块向 builtins/object-proto.ts 注册**接收者 toString 解析
+ *   钩子**（Object.prototype.toLocaleString 委派 this.toString()）——注册式
+ *   注入断开 builtins↔exec 的 import 环（同 protoMethodDispatch 口径）。
+ * - Bug 325：fn impl 的 kind 值域含 "async-generator"（与 "generator" 同有
+ *   原生 prototype）——prototype 面读该戳。
  */
 
 declare function namespaceNameOf(v: unknown): string | undefined;
@@ -524,8 +728,17 @@ declare function namespaceNameOf(v: unknown): string | undefined;
 declare function $regex(pattern: string, flags?: string): Abs;
 /** 成员读：obj.slots[key]；缺失 → undefined 字面量；brand 解包内层 */
 declare function $get(o: Abs, key: string, opts?: {
-    silent?: boolean;
-}): Abs;
+    /** 调用方已负责诊断（如 $invoke） */ silent?: boolean;
+    /** Bug 149：键来自符号投影（"[Symbol.X]" → "@@X"）——陷阱边界还原真 symbol */
+    symbolKey?: boolean;
+}, 
+/**
+ * Bug 235：[[Get]] 的 **receiver**（规范 Proxy.[[Get]](P, key, Receiver)
+ * 无 get 陷阱时转发 `target.[[Get]](key, Receiver)`）。缺省 = 接收者自身。
+ * 只作用于本次读取的访问器 `this` 绑定——不向下递归传递（内层读取的
+ * receiver 仍是它自己的接收者）。
+ */
+receiver?: Abs): Abs;
 /** 成员写：返回新 obj/brand（不可变更新）；frozen/sealed/只读目标按 sloppy 静默失败。
  *  opts.internal（Bug 84）：私有字段落地——槽打 Slot.internal 标记；后续覆写
  *  保留既有标记（this.#x = v 不丢失 internal）。
@@ -538,45 +751,26 @@ declare function $set(o: Abs, key: string, value: Abs, opts?: {
 }): Abs;
 
 /**
- * async / await / generator / ??（$nullishTest / $removeNullish）。
+ * 空值 / 类型 / 相等 / 关系守卫的臂剪影（narrowing）运行时。
+ *
+ * 域：转译器在守卫臂内对绑定名做的影子重绑（`exec/transpile/stmt-predicates.ts`
+ * 发射、`runtime.ts` facade 转出）：
+ * - nullish：`$removeNullish` / `$removeNull` / `$removeUndefined` /
+ *   `$removeMemberNullish`——按 term 字面量逐成员剥离 null / undefined
+ *   （Bug 3 粒度），`$nullishTest` 产出 `??` / `??=` 的测试值；
+ * - typeof：`$narrowTypeOf` 按 typeof 分类剪 union 成员（事实臂 / 补集臂）；
+ * - 判别等值：`$narrowMemberEq` 按 key 槽的字面量事实剪成员（issue #126）；
+ * - 关系：`$refineRel` 给关系事实臂挂界（Bug 1）。
+ *
+ * 共享 nullish 谓词：`isNullishLitAbs` / `definitelyNotNullishShape`
+ * （surface.ts）与本地 `isNullLitAbs` / `isUndefLitAbs` /
+ * `definitelyNullishAbs` 是同一套逐成员判定口径——各剪影的「剪空 → 原样
+ * 返回」保守分支都以此为准；其它 runtime 文件不要另造第二套。
+ *
+ * 本文件不依赖 async / generator 机制（单向：runtime/async.ts 与
+ * runtime.ts 只做转出）；新增 narrow 算子放这里，不要回填 async.ts。
  */
 
-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 值；返回带迭代器协议面的生成器对象 Abs；
- *  抽象分支时降 conf（P0-6）
- *
- * Bug 58：调用生成器是原生全操作——体只在首个 next() 执行。body() eager
- * 执行的体内效果（成员读 may-throw / 显式 throw）不折进**调用方** throws
- * 域——以捕获式 may-throw 帧包裹：soft 效果与 NudoThrow 挂生成器对象
- * （Bug 34 延迟重放：首个触达抛点的 next()/迭代消费，仅构造不消费不
- * 表面）。yield 收集保持 eager（既有值域建模，注释口径不变）。
- * Bug 2：thunk 返回值 = 终末 return 值——不再丢弃，经 makeGenObject 在
- * 首个 done:true 作为 value 交付（node 实测：此后 next 回 undefined）。
- * Bug 22：结果从 yield 元组数组改为生成器对象（next/return/throw 方法面 +
- * constructor 身份）；元素域经侧表保留（$arr 的 ≤cap tuple / >cap arr
- * widen 策略不变），迭代路径（for-of/spread/Array.from）继续工作。
- * Bug 53：侧表/next() 消费完整收集序列（ys.els）——$arr >cap widen 只影响
- * 形状槽（类型面），不再把 >8 yield 截断成单元素流。
- * Bug 52：yield 点 try 上下文（ys.ctxs，$yield 第二实参）随序列传递——
- * .return()/.throw() 挂起点语义见 makeGenObject。 */
-declare function $gen(body: () => Abs): Abs;
-/** yield v：压入当前生成器收集器；表达式值用 unknown。
- *  tryCtx（Bug 52）= transpile 静态标注的 yield 点 try 上下文位
- *  （YIELD_TRY_FINALLY / YIELD_TRY_CATCH），.return()/.throw() 挂起点
- *  语义用（见 makeGenObject）。 */
-declare function $yield(v: Abs, tryCtx?: number): Abs;
-/** yield* v（Bug 82）：委托迭代 ≠ yield v——GetIterator 校验先行（$elems
- *  同分类器：非可迭代接收者 definite/may TypeError，生成器体内按 $gen
- *  迭代期语义由外层帧吸收），**元素**逐个压入收集器（此前把整个可迭代值
- *  压一次）；表达式值 = 内层迭代器的 return 值（生成器 return / 自定义
- *  iterator 的 done 值，不可判）→ 保守 unknown。长度不可判的接收者
- *  （arr/any/…）单代表元素过近似并入 + bumpGenPathSensitive 压 conf
- *  （mergeArmYields 同口径，禁 exact 元组出货）。 */
-declare function $yieldStar(v: unknown, tryCtx?: number): Abs;
 /**
  * `??` 非 nullish 臂：从左值 Abs 剥离 nullish 部分（$nullishTest 判 true
  * 的成员）。索引访问 `M[k]` 对抽象键产出 joinAbs(element, undef())，
@@ -649,14 +843,164 @@ declare function $narrowMemberEq(a: Abs, key: string, value: string | number | b
 /** `??` / `??=` 测试：确定非 nullish → false；lit nullish → true；否则抽象 boolean */
 declare function $nullishTest(v: Abs): Abs;
 
+/**
+ * async / await / generator 运行时（nullish / typeof / 判别 / 关系守卫的臂
+ * 剪影在 runtime/narrow.ts，本文件只为深路径导入者做兼容转出）。
+ *
+ * 不变量（本文件）：
+ * - `$await` 的取值面 = 原生的 adopt 口径：promise 走 eff("promise") 通道
+ *   （**双臂** promise 的 rejected 臂不得丢——记入 throw 通道供体内
+ *   try/catch 吸收，未被吸收者并入 promise 的 rejected 通道）；**thenable**
+ *   （闭对象 + 自有 then 槽）走 PromiseResolve 式采纳（取 then(res, rej)
+ *   的 settle 值，不是 thenable 本身）。any/unknown/fn/开对象的采纳面
+ *   不可判 → 保持原值（不猜、不用 unknown 掩盖）。
+ * - Bug 1052：thenable 采纳的**判定与调用**与 promise 构造面（`Promise.resolve`
+ *   / `new Promise(resolve => resolve(thenable))`）**同一套机制**
+ *   （`builtins/promise.ts` 的 `thenableAdoption`）——本文件只做 await 面的
+ *   语义映射（reject → throw；未 settle → 悬挂）。
+ * - 生成器对象是**内部槽对象**：协议方法与 yield 元素的槽标 internal
+ *   （枚举面 / 自有面不可见；$get / $in 照常直读直查）。
+ * - `yield*` 委托的 `.return(v)` 必须**转发**给委托迭代器（委托的清理
+ *   副作用不得整体丢失）。
+ */
+
+declare function $async(thunk: () => Abs): Abs;
+/**
+ * Bug 201：async 体的**真挂起**路径（宿主生成器驱动）。
+ *
+ * 转译侧：async 体（**直接含 await**）编译成宿主生成器 `function*(){…}`，
+ * `await x` 发射 `yield x`（挂起点 + 被等待值）。本函数驱动生成器：
+ *
+ * - **同步段**：跑到第一个挂起点即返回 promise（inner 暂 unknown）⇒
+ *   await 之后的语句**不在调用点内联跑完**（原生：恢复点是微任务）。
+ * - **续体**：登记到宿主微任务队列（与 promise reaction **同一队列** ⇒
+ *   跨 promise 链的先后顺序天然保真——上游 promise 的续体先跑，下游
+ *   `await` 恢复时读到的已是上游终值）。
+ * - **值域**：续体跑完 ⇒ 就地填 promise 的 inner（终值由续体给出）。
+ *
+ * 与 `$async(thunk)` 的分工：**无 await 的 async 体**没有挂起点，沿用
+ * `$async` 的同步路径（发射产物逐字不变 ⇒ 既有金标零漂移）。
+ *
+ * Bug 1126：live `$asyncGen` promise 带 **pending 态**（体尚未 settle）与
+ * **waiter 列表**（等它 settle 才恢复的 await 恢复点）。
+ *
+ * **机制共用**（Bug 1148）：pending 判定 + waiter 冲刷抽到
+ * `builtins/promise.ts` 的 `pendingPromiseWaiters`（`registerPendingPromise` /
+ * `isPendingPromiseShape` / `onPromiseSettled` / `flushPromiseWaiters`）——
+ * `Promise.all` 的活通道聚合（元素 settle 后刷新兑现值）与本文件的 await 恢复
+ * 点**同一套** pending 机制（不另造第二套）。
+ *
+ * 键 = promise 的 shape 对象（活通道本体：`inner` 就地填）。每个 `$asyncGen`
+ * 调用一个 shape ⇒ 键唯一；WeakMap ⇒ 随 promise 回收，不泄漏。
+ *
+ * **不挂在 shape 上**：`Shape` 是 `abs.ts` 的公开联合类型（eff 面无 pending
+ * 槽），且 waiter 闭包不该进投影 / 指纹面（`absShapeKey` / `shapeKey` 只读
+ * `inner`）。
+ */
+declare function $asyncGen(genFn: () => Generator): Abs;
+/** await → 解包 eff("promise") */
+declare function $await(v: Abs): Abs;
+/** function* 体：收集所有 yield 值；返回带迭代器协议面的生成器对象 Abs；
+ *  抽象分支时降 conf（P0-6）
+ *
+ * Bug 58：调用生成器是原生全操作——体只在首个 next() 执行。body() eager
+ * 执行的体内效果（成员读 may-throw / 显式 throw）不折进**调用方** throws
+ * 域——以捕获式 may-throw 帧包裹：soft 效果与 NudoThrow 挂生成器对象
+ * （Bug 34 延迟重放：首个触达抛点的 next()/迭代消费，仅构造不消费不
+ * 表面）。yield 收集保持 eager（既有值域建模，注释口径不变）。
+ * Bug 2：thunk 返回值 = 终末 return 值——不再丢弃，经 makeGenObject 在
+ * 首个 done:true 作为 value 交付（node 实测：此后 next 回 undefined）。
+ * Bug 22：结果从 yield 元组数组改为生成器对象（next/return/throw 方法面 +
+ * constructor 身份）；元素域经侧表保留（$arr 的 ≤cap tuple / >cap arr
+ * widen 策略不变），迭代路径（for-of/spread/Array.from）继续工作。
+ * Bug 53：侧表/next() 消费完整收集序列（ys.els）——$arr >cap widen 只影响
+ * 形状槽（类型面），不再把 >8 yield 截断成单元素流。
+ * Bug 52：yield 点 try 上下文（ys.ctxs，$yield 第二实参）随序列传递——
+ * .return()/.throw() 挂起点语义见 makeGenObject。
+ * Bug 141：asyncMode（第二实参）= async generator 面——迭代结果经 promise
+ * 交付（next/return/throw 返 promise）、装 @@asyncIterator 自返槽与
+ * @@toStringTag "AsyncGenerator"（原生 async function* / async * 方法）。 */
+declare function $gen(body: () => Abs, asyncMode?: boolean): Abs;
+/** yield v：压入当前生成器收集器；表达式值用 unknown。
+ *  tryCtx（Bug 52）= transpile 静态标注的 yield 点 try 上下文位
+ *  （YIELD_TRY_FINALLY / YIELD_TRY_CATCH），.return()/.throw() 挂起点
+ *  语义用（见 makeGenObject）。 */
+declare function $yield(v: Abs, tryCtx?: number): Abs;
+/** yield* v（Bug 82）：委托迭代 ≠ yield v——GetIterator 校验先行（$elems
+ *  同分类器：非可迭代接收者 definite/may TypeError，生成器体内按 $gen
+ *  迭代期语义由外层帧吸收），**元素**逐个压入收集器（此前把整个可迭代值
+ *  压一次）；表达式值 = 内层迭代器的 return 值（生成器 return / 自定义
+ *  iterator 的 done 值，不可判）→ 保守 unknown。长度不可判的接收者
+ *  （arr/any/…）单代表元素过近似并入 + bumpGenPathSensitive 压 conf
+ *  （mergeArmYields 同口径，禁 exact 元组出货）。 */
+declare function $yieldStar(v: unknown, tryCtx?: number): Abs;
+
 type TranspileOptions = {
-    /** 运行时 import 说明符 */
-    runtimeImport?: string;
+    /**
+     * 运行时 import 说明符。
+     *
+     * `null` = **不发射**运行时 import 行（宿主编译：`new Function` 单元以
+     * 形参注入运行符号）。缺省 = `@nudojs/core/exec`。
+     */
+    runtimeImport?: string | null;
+    /**
+     * 发射目标（缺省 `"esm"`，既有产物逐字节不变）：
+     * - `"esm"`：保留标准 `import` / `export` 语句（run.ts 后处理改写）；
+     * - `"host"`：直接发射宿主编译形态——import → `__nudoBindImport` /
+     *   `__nudoBindNamespace` 绑定，export → `__nudoExport*` 调用，不残留任何
+     *   `import` / `export` 语句，也不发射运行时 import 行（宿主以形参注入）。
+     */
+    target?: "esm" | "host";
+    /**
+     * 发射模式（缺省 `"exec"`）：
+     * - `"exec"`：完整发射（全部顶层语句，含副作用）；
+     * - `"analyze"`：**发射期**剥离顶层效应语句——顶层 `if` / `for` /
+     *   `while`、危险或未知全局调用（判定表见 `transpile/analyze-strip.ts`）；
+     *   `var` 提升仍按**原始**源 AST 计算。调用方（run.ts 的 analyze 模式）
+     *   不再解析生成产物做二次剥离；保留语句的发射字节与 `"exec"` 完全一致，
+     *   剥离只减少语句。
+     *
+     * `for-in` / `for-of` **不剥离**（判定表无该臂）：二者按发射形态落顶层
+     * `$forOf(...)` 调用（循环体随该调用在模块顶层执行）⇒ analyze 模式保留
+     * 其语义；标签 `for` / `while` 随标签一并剥离。
+     */
+    mode?: "exec" | "analyze";
+    /**
+     * host target 的 mock 名集：命中的 import 本地名绑定 `__nudoEnv[<名>]`
+     * 而非 `__nudoBindImport` / `__nudoBindNamespace`，且不登记 live refresh
+     * （刷新会把 mock 冲掉）。esm target 忽略（run.ts 的文本改写负责 mock）。
+     */
+    mockNames?: ReadonlySet<string>;
+    /**
+     * @internal host target 的 live import refresh 发射状态（transpileFile
+     * 创建并跨语句线程化）：`binds` 是全量刷新赋值文本（按源序，已排除
+     * mock），`done` 标记注册行是否已随首个「产生绑定」的 import 语句发射。
+     * 直接调用 `transpileStatement` 的低层单元不传 ⇒ 不发射注册行。
+     */
+    hostImportRefresh?: {
+        readonly binds: readonly string[];
+        done: boolean;
+    };
     maxLoopIters?: number;
     /** 方法/函数体内 this 的绑定名（transpile class 时注入） */
     thisParam?: string;
+    /**
+     * Bug 1160：本转译单元**共享**的 this 载体名（`__this` 基名经
+     * `internalTmpName` 分配）。载体是跨发射器协议——真函数体 prologue
+     * （`let <名> = $rawThis(this)`）与类/对象方法、访问器 thunk、字段 /
+     * 静态块 thunk 的首参**一方声明、多方读**（读方即 `thisParam`）——必须
+     * 同名。根转译单元（`transpileFile` / `transpileBodyNode`）分配一次并
+     * 线程化；无碰撞时基名 `__this` 原样返回 ⇒ 产物逐字不变。
+     */
+    thisSlot?: string;
     /** 当前类名（super 派发用） */
     className?: string;
+    /**
+     * Bug 133：类表达式的 **NamedEvaluation 名**（`const K = class {}` → "K"）。
+     * 只对**本表达式自身**生效——类体内的嵌套类表达式拿不到该名（原生内层
+     * 仍是无名类）；类自身的名字（`class Named {}`）优先于绑定名。
+     */
+    classNameHint?: string;
     /**
      * 静态方法体内 super 的接收者源（父类构造器——extends 表达式经
      * classSpecOf 前移计算注入）。super.x / super.m() / super[k] 落通用
@@ -670,11 +1014,17 @@ type TranspileOptions = {
     replacements?: Array<{
         target: string;
         varName: string;
-        /** 仅该语句范围内生效（1-based 行） */
+        /**
+         * 仅该**节点**范围内生效——字符区间 `[stmtStart, stmtEnd)`
+         * （Babel 节点的 start/end 偏移），**不是行号**：Bug 166 修法把
+         * 「行号窗口」改成「AST 节点身份」，行号窗口会泄漏进嵌套/同行的
+         * 其它子表达式。
+         */
         stmtStart?: number;
         stmtEnd?: number;
     }>;
-    /** @nudo:as：覆盖紧随语句的 init / return */
+    /** @nudo:as：覆盖紧随语句的 init / return（stmtStart/stmtEnd = 字符区间，
+     *  语义同上——按节点身份定位，不按行号） */
     asOverrides?: Array<{
         varName: string;
         stmtStart: number;
@@ -692,6 +1042,19 @@ type TranspileOptions = {
     lenientGlobals?: boolean;
     /** try 嵌套深度（>0 时 return 前 drain throwExits，使 catch 能吸收抽象 throw） */
     inTry?: number;
+    /**
+     * 「块完成 ≠ 函数尾」深度（>0 时**早退提升**走控制流协议而非「返回值」
+     * 协议）。
+     *
+     * 族 65 · BC #28：try / catch / finally **块体**的完成不是函数尾（块跑完
+     * 后函数继续往下走）⇒ 早退提升（fn-body.ts）的 alt 臂（后续路径）跑完后
+     * **不得**把它的值当函数返回值抛出。此前只有 `inTry` 计入 inCtrl ⇒ catch /
+     * finally 体（inTry 不加）落「返回值」协议（`return $fork(...)`）⇒ 后续
+     * 路径的值被当成函数返回值（自信的错值）。
+     *
+     * 与 `inTry` 分开：inTry 另有职责（return 前 drain throwExits）。
+     */
+    inCtrlBlock?: number;
     /** 当前 try 的 mark 变量名（return drain 用；避免全局栈顶污染） */
     tryMarkName?: string;
     /** 当前 try 是否带 catch handler（soft may-throw digest/release 分支） */
@@ -707,6 +1070,40 @@ type TranspileOptions = {
     yieldTryCtx?: number;
     /** 分支/循环体内深度（赋值记录 conditional 标记；inLoop 也计入） */
     conditionalFlow?: number;
+    /**
+     * 当前处在 **async 函数体**内（Bug 201）。
+     *
+     * async 体内的 `await` 是**真挂起点**：发射 `yield <operand>`（宿主生成器
+     * 挂起），由 `$asyncGen` 驱动恢复 ⇒ await 之后的语句不在调用点内联跑完
+     * （原生：恢复点是微任务）。
+     *
+     * 函数/方法体边界重置：async 体 ⇒ true；**非** async 体 ⇒ false（嵌套
+     * 同步函数不得继承——它不是生成器，`yield` 会是语法错误）。
+     */
+    inAsyncBody?: boolean;
+    /**
+     * **强制关闭** async 体的生成器路径（`$async` 同步路径）。
+     *
+     * Bug 1139（安全网）：`await` 的位置表（`async-plan.ts`）与转译侧一旦脱节，
+     * `yield` 会落进嵌套箭头 ⇒ `new Function` SyntaxError ⇒ **整个模块**编译
+     * 失败 ⇒ 全部导出丢失 ⇒ L2 闸门**假绿**（exit 0）。求值引擎在生成器模式
+     * 编译失败时以本开关**重试一次** ⇒ 模块至少编译得出来 ⇒ 导出可见 ⇒ 闸门
+     * 照常判定（宁可少精确，不可整模块消失）。
+     */
+    disableAsyncGen?: boolean;
+    /**
+     * 当前 async 体内**需发挂起门**的 `for await` 语句节点（节点身份）。
+     *
+     * Bug 201：原生 `for await` 每轮一个 await；引擎既有建模是同步驱动 ⇒
+     * 生成器级发**整循环一个**挂起门（循环前 `yield`）。只有落在**生成器级**
+     * 位置（生成器体内联）的 for await 才能发门——分支臂/循环体里的 for await
+     * 是宿主 thunk（`yield` 会是语法错误）⇒ 由 async-plan 判定排除。
+     *
+     * 键 = 源偏移量（`String(node.start)`）——转译侧会**浅拷贝**语句节点
+     * （completeElseChains / flattenEarlyReturnBlocks）⇒ 节点身份不稳定，
+     * 源偏移量在拷贝间稳定。
+     */
+    asyncForAwaitGates?: ReadonlySet<string>;
     /** 函数/箭头体内（顶层绑定表只收顶层作用域） */
     inFunction?: boolean;
     /**
@@ -739,6 +1136,56 @@ type TranspileOptions = {
      * 成员/下标写对根的内部重绑不在用户赋值路径，不走此表。
      */
     constNames?: ReadonlySet<string>;
+    /**
+     * 直接 const 别名组（`const a = {...}; const b = a;`）。
+     *
+     * fork/循环 pack 只按「被写绑定」收集快照名；别名伙伴不在集合里时，
+     * 臂/轮次结束把 `a` 重绑为副本会断开 `b` 的引用语义。该表在**作用域
+     * 边界**上计算（只收 init 为同作用域、此前已声明 const 的标识符，避免
+     * TDZ 与可重绑 let）：函数/方法体与嵌套块由 transpileFnBodyStmts 算，
+     * **模块顶层**（模块体逐语句发射、不经函数体入口）由 transpile.ts 算。
+     * 嵌套作用域**继承**外层组并按自身遮蔽名过滤（未被遮蔽 ⇒ 同一绑定，
+     * 展开安全；被遮蔽 ⇒ 该组在本处指向不同绑定，丢弃），fork/pack 发射时
+     * 据此扩展 snapshot 集合。
+     */
+    aliasGroups?: ReadonlyArray<readonly string[]>;
+    /**
+     * 本转译单元内被用户绑定**遮蔽**的宿主内建名（undefined / NaN / Infinity
+     * 的子集，保守单位级）。
+     *
+     * 名字是**宿主全局**但用户可合法遮蔽（`const undefined = 5`、形参名
+     * `undefined`、`let NaN`、import 绑定）。命中者按**位置**分态：
+     * - Identifier 读点（含标签模板位）→ `$absVal(<名>)`，由 JS 词法绑定
+     *   决定读值；
+     * - 调用位 callee → `$callNamed(<名>, <名>, …)`（绑定是 Abs 值，宿主裸
+     *   调用会把它当非函数调 ⇒ 假抛 TypeError）。
+     *
+     * 未命中者：读点恢复字面量精确折叠（`$lit(void 0)` / `$lit(0/0)` /
+     * `$lit(1/0)`，与旧产物逐字节一致），调用位保留宿主裸调用（原生
+     * `undefined(1)` / `NaN(1)` 定抛 TypeError，抛点与原生一致）。
+     *
+     * 计算：`transpileFile` 从源 AST 声明扫描（任意作用域，保守单位级）；
+     * `transpileBodyNode` 从 body AST 计算并并入调用方补给；body-fn 补给
+     * 形参 / 闭包绑定名；evalExprAbs 补给注入的 bindings 名 **∪ 表达式 AST
+     * 声明扫描**；表达式入口（exec/transpile/expr.ts 的 `transpileExpression`）
+     * 同补声明扫描（表达式内部的形参 / 局部声明此前不可见）；run.ts 补给
+     * @nudo:mock 注入的内建名（env 注入本就跳过这三个名字）。
+     *
+     * 静态窄化面：`x === undefined` / `case undefined:` 只在**未遮蔽**时作
+     * 字面量事实——遮蔽后该标识符是普通绑定，比较值是绑定值（如 5）。
+     */
+    shadowedIntrinsics?: ReadonlySet<string>;
+    /**
+     * **调用方补给的**用户标识符词形集（Bug 1058 避让的补充来源）。
+     *
+     * `internalTmpName` 的避让集 = `userIdentInfo(opts.source).names`（源文本
+     * 词形）∪ 本集合。用于**没有源文本**的转译单元——`exec/body-fn.ts` 的
+     * body 编译路径（`transpileBodyNode(impl.body, …)` 原先传空 opts ⇒ 无
+     * source ⇒ 避让集恒空 ⇒ 引擎内部临时名与用户标识符相撞 ⇒ 产物非法 JS
+     * ⇒ 整模块 fail-closed）。该路径的调用方从 **AST** 收标识符词形
+     * （body 内全部 Identifier + 形参名）补进来。
+     */
+    userIdents?: ReadonlySet<string>;
     /**
      * 本作用域已提升到函数体顶部的 var 名（Bug 21）：块内 `var x = init`
      * 改发赋值 `x = init`（绑定由顶部 `let x = $lit(void 0)` 提供）。
@@ -750,6 +1197,21 @@ type TranspileOptions = {
      * 声明语句），此类名字从提升集扣除、不发改赋值。
      */
     keepVarDecl?: boolean;
+    /**
+     * 本文件**真实**的静态声明导出名（源 AST：`export function|class|const|let`
+     * / `var`，多声明符全收；解构声明不收内部名）。
+     *
+     * 只有顶层 FunctionDeclaration 的名字命中本集合时才发射 `export ` 前缀
+     * ——此前所有顶层函数一律带 export（发射 quirk）⇒ run.ts 的文本回收把
+     * 私有顶层函数当导出 ⇒ `export *` 被本地私有同名函数遮蔽、私有名泄漏进
+     * 模块导出面、转译产物作为真实 ESM 时多出导出。
+     *
+     * `export { f }` specifier 名**不**在此集合（同名声明未必是声明式导出；
+     * run.ts 在运行时把 specifier 改写成 __nudoExportLazy）。
+     * transpileFile 从已解析 AST 计算并线程化；缺省（直接调用
+     * transpileStatement 的低层单元）⇒ 不发 export。
+     */
+    exportedDeclNames?: ReadonlySet<string>;
     /**
      * issue #165：文件含 `@nudo:assume` 引理——transpileFile 顶层对源文本
      * 做一次 includes 判定后置位。文件级快速门：无引理的文件不进锚定收集，
@@ -779,6 +1241,14 @@ type TranspileOptions = {
 /**
  * transpile 共享 AST 工具：形参名、match、fold、静态键、作用域收集、mutator receiver 扫描。
  * 不依赖 stmt/expr 发射器（无环）。
+ *
+ * 不变量（@nudo:as / @nudo:replace 指令面）：
+ * - **作用范围按 AST 节点身份**（源文本字符区间 [start, end)）判定，
+ *   不是「同一行号窗口」：多行语句 / 嵌套块 / 同行下一条语句都不再被命中
+ *   （Bug 166）。as 的目标是**承载指令的那条语句**；replace 的目标是该
+ *   语句子树内、**不跨作用域边界**的子表达式节点（边界在收集面划定）。
+ * - **replace 命中的子表达式仍要求值**（副作用与 throws 域保留），只是
+ *   结果被注入值取代（Bug 165）；旧口径整段替换 → 副作用与抛错域消失。
  */
 
 /**
@@ -792,6 +1262,22 @@ declare function foldStaticStringExpr(node: unknown): string | undefined;
 /** require(...) 第一个参数 → 可折叠说明符（StringLiteral / 模板 / 字面量拼接） */
 declare function foldRequireSpecArg(arg: unknown): string | undefined;
 
+/**
+ * 运行时 import 行（body-fn 编译执行 / evalExprAbs / 模块体拼接用）。
+ * 产出形态：`import { $a, $b } from "<runtime>";`（单行，双引号说明符）。
+ */
+declare function runtimeImportOf(runtime: string): string;
+/**
+ * 宿主编译前**剥离**上面那行 import 的正则（默认 ESM 产物 / 旧调用方）。
+ *
+ * `new Function` 单元没有 ESM 导入面——运行符号是形参注入（rt.ts 的
+ * compileRuntimeUnit）。host target（`runtimeImport: null`）不发射该行；
+ * 默认 ESM 产物若被宿主直接编译，仍需本正则剥离。只认**双引号**说明符
+ * （runtimeImportOf 的产物）；用户源码的 import 由 host target 的
+ * `emitHostImportDeclaration` 直接发射绑定。
+ */
+declare const RUNTIME_IMPORT_RE: RegExp;
+
 /**
  * 方法/函数体统一发射（stmt 按域拆分之一；语句 switch 在 ./statement.ts）。
  *
@@ -800,6 +1286,14 @@ declare function foldRequireSpecArg(arg: unknown): string | undefined;
  *   （emitFnBlockBody / transpileFnBodyStmts）——逐语句 map(transpileStatement)
  *   会绕过早退 if 提升，`if (c) return X; return Y` 的早退值被语句级 $fork
  *   thunk 吞掉（假精确）；
+ * - 早退提升的 alt 臂 = **后续路径**（事实臂已 return/throw 提前退出 ⇒ 测试
+ *   为假）⇒ 该臂**不断言否定关系界**（Bug 1115：¬(x <= k) 含 NaN，不可健全
+ *   表示 ⇒ 断言否定界会把 NaN 排除 ⇒ 假绿；事实臂窄化不受影响）；
+ * - 早退摊平的**送达范围**（Bug 186）：内含早退 if 且**无词法声明**的块
+ *   摊平到当前语句表（flattenEarlyReturnBlocks）——块正常完成 ⇒ 早退测试为
+ *   假；块内有词法声明时不摊平（作用域不外泄）；
+ * - try / catch / finally 的**块体**也走本入口（与函数体顶层同口径）——裸
+ *   map(transpileStatement) 会绕过早退提升；
  * - 函数体边界 var 提升（Bug 21）：skip = 参数模式名；嵌套块不传
  *   varScope（var 已在函数级提升，块内改发赋值）；
  * - P4b 参数遮蔽：继承 constNames 被本函数参数模式名遮蔽时扣除（假
@@ -808,27 +1302,56 @@ declare function foldRequireSpecArg(arg: unknown): string | undefined;
  *   （Bug 9：先用后声明时 new g() 不误判）。
  */
 
+/**
+ * 关系守卫的**补集**精化已**整体撤销**（Bug 1115）。
+ *
+ * 原实现（Bug 182）在「测试为假」的后续路径上断言**否定关系界**
+ * （`x <= k` 为假 ⇒ `x > k`，`REL_COMPLEMENT_OP`）——但 JS 里
+ * `¬(x <= k)` 还含 `x` 为 NaN 的情形（NaN 与任何比较皆假）：
+ * 后续路径只能断定 `x > k ∨ x is NaN` ⇒ 断言 `x > k` **排除了 NaN**
+ * （不健全）⇒
+ * - `if (x < 0) return 0; return x;` + `return nonNeg`：后续路径断言
+ *   `x >= 0` ⇒ 契约被「证成」⇒ **0 诊断**（假绿）；原生 x=NaN ⇒
+ *   `NaN < 0` 为假 ⇒ `return x` ⇒ 返回 NaN ⇒ 违反 nonNeg（真违规）。
+ * - 三元写法 `return x < 0 ? 0 : x;` 的 else 臂没有否定界窄化 ⇒ 判
+ *   `unproven-return` ⇒ 两种等价写法结论不一致。
+ *
+ * ⇒ 后续路径**不断言否定界**（事实臂 `narrowRelArmThunk` 保留：那一侧
+ * 「测试为真」⇒ NaN 不可达，断言是健全的）。
+ */
 declare function transpileBodyNode(node: Node, opts: TranspileOptions): string;
 
 /**
- * 表达式发射主分派（expr 按域拆分之一；各节点类别族在兄弟模块）。
+ * 表达式发射：transpileExpression / transpileShortCircuitExpr。
+ * 按域拆分（facade 保持原导入面不变）：
+ * - transpile      主分派（replace/Chain/可选链入口/switch 路由 + dispatch bind）
+ * - short-circuit  $fork 短路协议（&&/||/??/三元/逻辑赋值）
+ * - optional-chain 可选链整链短路（flatten/emit/delete 链）
+ * - atom           字面量/标识符/模板/import()/JSX
+ * - operators      二元逻辑/条件/一元/更新/await/yield/序列
+ * - member         成员读（静态/计算/私有名/length/super 读）
+ * - call           调用/new/super 调用/require
+ * - object         对象/数组字面量与展开
+ * - assignment     赋值/复合赋值/逻辑赋值/解构赋值
+ * - function       函数/类表达式 + 参数模式名
  *
- * 不变量：
- * - 入口顺序：@nudo:replace 替换 → ChainExpression 剥壳 → 可选链整链短路
- *   （./optional-chain.ts）→ Super 接收者 → 按节点类别族路由；未 lowering
- *   的表达式统一 default unsupported（不得假精确 undefined）；
- * - positionRecordWrap 只包一次：内部递归一律经 transpileExpression 入口，
- *   族模块回环经 transpile-dispatch 别名（emitTranspileExpression）；
- * - SSR 加载序陷阱：模块体尾部的 dispatch bind 是加载期副作用——必须直接
- *   import leaf（transpile-dispatch）与定义模块（./short-circuit.ts），不经
- *   facade/barrel 中转（vite SSR 下 barrel 再导出不是实例化期绑定）。
+ * 本文件是**表达式入口**（公开面）：`transpileExpression` 在此补遮蔽判定
+ * （见下方函数注释）——主分派（./expr/transpile.ts）保持纯发射。
  */
 
 /**
- * 表达式发射入口（位置插桩包装层）。recordPositions 时把
- * Identifier 值读 / 静态成员读的转译输出包 `$nodoPos`——
- * 运行时记 (行, 列) → Abs 并原样返回（语义恒等；无收集
- * 器时直通）。内部递归经本包装——每个子表达式恰包一次。
+ * 表达式入口（公开面）：**遮蔽判定**补声明扫描。
+ *
+ * 宿主内建名（undefined / NaN / Infinity）的读点按遮蔽分态（未遮蔽 → 字面量
+ * 精确折叠；已遮蔽 → 标识符读点 `$absVal`，由 JS 词法绑定决定读值）。模块
+ * 入口（transpileFile / transpileBodyNode / body-fn）按**单元级**扫描声明
+ * 绑定名判定；表达式入口此前只信调用方给的 `opts.shadowedIntrinsics` ⇒ 表达
+ * 式**内部**的声明（形参名 undefined / 局部 let / const / var / catch 参数）
+ * 不可见 ⇒ 体折宿主内建（原生读的是绑定值 ⇒ 自信的错值）。
+ *
+ * 口径与模块入口同源（helpers.ts 的 shadowedIntrinsicsOf）：单元级**保守**
+ * 扫描（任意作用域出现同名绑定即计入）∪ 调用方已给的遮蔽集（注入名 / mock）。
+ * 无命中 → 不写 opts 字段 ⇒ 产物逐字节不变。
  */
 declare function transpileExpression(expr: Expression, opts?: TranspileOptions): string;
 
@@ -838,12 +1361,16 @@ declare function transpileExpression(expr: Expression, opts?: TranspileOptions):
  * 值类型是 Abs；副作用与模块仍由 host mock/注入。
  *
  * 实现按语句/表达式/模式拆在 transpile/*.ts；本文件是 re-export facade，
- * 对外符号面保持不变（exec/index.ts `export * from "./transpile.ts"`）。
+ * 对外符号面保持不变（exec/index.ts 对公开符号做显式具名导出）。
+ *
+ * 不变量（解构临时名，Bug 181）：
+ * - 模块级解构临时名计数器（`destrTmpSeq`）在**创建处**即预置避让：序号
+ *   推过用户已占用的 `_d{n}` / `_n{n}` ⇒ 首次分配（模块首条语句即解构
+ *   声明）也拿不到与用户同名绑定重复的临时名（重复词法声明 ⇒ SyntaxError
+ *   ⇒ 整模块求值失败 ⇒ 导出退化 unknown）。
  */
 
 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;
@@ -877,10 +1404,19 @@ type EvalClassSpec = {
     methods?: Record<string, (thisVal: Abs, ...args: Abs[]) => Abs>;
     /** 实例方法形参展示名（AST 形参名；未调用方法槽 `shape.params` 用） */
     methodParams?: Record<string, string[]>;
+    /**
+     * Bug 325：实例方法的**函数种类**戳（async × generator 四象限）——
+     * 原生类方法的标签面（Object.prototype.toString.call(A.prototype.m)）
+     * 随 async / generator 变（"[object AsyncFunction]" 等）。类方法**同时**
+     * 可能是 generator ⇒ 与 impl.kind 的派发角色维度分开承载。
+     */
+    methodKinds?: Record<string, "function" | "async" | "generator" | "async-generator">;
     /** R5：静态方法 impl 首参 __this = 类值（接收者——沿链调用时是调用类） */
     staticMethods?: Record<string, (thisVal: Abs, ...args: Abs[]) => Abs>;
     /** 静态方法形参展示名 */
     staticMethodParams?: Record<string, string[]>;
+    /** Bug 325：静态方法的函数种类戳（实例方法同口径） */
+    staticMethodKinds?: Record<string, "function" | "async" | "generator" | "async-generator">;
     /**
      * P2b：构造器元数（首个默认值/rest 形参前的形参数，nativeParamArity
      * 口径）——类值 .length 自有属性。隐式构造器（基类零参 / 派生
@@ -927,7 +1463,7 @@ declare function getEvalClass(name: string): EvalClassSpec | undefined;
 declare function clearBClasses(): void;
 
 /**
- * 类声明/注册/构造：$class/$new/$staticInit + registry 辅助。
+ * 类声明/注册/构造：$class/$new + registry 辅助。
  *
  * Invariants:
  * - classImpl（WeakMap）是 spec 的唯一私有挂载点：Abs 对象身份 → 定义
@@ -938,20 +1474,15 @@ declare function clearBClasses(): void;
  *   withNewTargetReset 包裹（嵌套 new 不串帧）。
  */
 
-/** 定义类 → 可 new 的 Abs（brand 标记；静态字段挂在 slots） */
+/** 定义类 → 可 new 的 Abs（brand 标记；静态字段挂在 slots）。
+ *  displayName（Bug 133）：对外可见的 **name**（原生无名类名为空串）；缺省
+ *  用内部类名（类声明 / 具名类表达式同口径）。 */
 declare function $class(name: string, spec: Omit<EvalClassSpec, "name"> & {
     extends?: string | Abs | unknown;
     hasExtends?: boolean;
-}): Abs;
+}, displayName?: string): Abs;
 /** new C(...) → 空 brand 实例 + ctor 写字段；非类构造走 impl/$call */
 declare function $new(cls: Abs | ((...a: unknown[]) => unknown), args: Abs[]): Abs;
-/**
- * Bug 77：静态块在类定义期执行（原生 ClassDefinitionEvaluation 的
- * InitializeStaticElements）。transpile 在 `let C = $class(...)` 绑定完成
- * **之后**发射本调用——块体内类名按词法可见（原生 static 块内类绑定已
- * 初始化）；this 绑定类值；块内 throw 在定义点表面（NudoThrow 上浮）。
- */
-declare function $staticInit(cls: Abs, thunks: Array<(thisVal: Abs) => unknown>): void;
 
 /**
  * super 家族：$super/$invokeSuper/$getSuper/$setSuper + 对象超与静态超。
@@ -1019,42 +1550,48 @@ declare function $setSuperStatic(thisVal: Abs, childName: string, key: Abs, valu
  * - 数组方法（map/filter/reduce/…）委派 invokeArrMethod（invoke-arr.ts）；
  *   mutator 语句快路径在 transpile 层（emitArrMutatorRebinds），两条路径
  *   的元素域语义必须同口径（issue #153：SpreadElement 折 $unknown 的教训）。
+ * - Bug 152：实参可以是 **thunk**（`() => [args]`）——调用点成员**先于实参**
+ *   求值（原生 CallExpression 顺序：引用取值（getter 在此触发）→ 实参 →
+ *   调用）。thunk 形态：$invoke 先读成员（预读），再求实参，最后派发；
+ *   派发复用预读值（不再二次读 ⇒ getter 只跑一次）。预读对 sum（union）
+ *   接收者跳过（派发按成员各读一次，预读会重复触发 getter）。
  */
 
 /** 实例方法调用：沿继承链；类 Abs 上回落 staticMethods；obj 上回落属性函数 */
-declare function $invoke(thisVal: Abs, method: string, args: Abs[], loc?: [number, number]): Abs;
+declare function $invoke(thisVal: Abs, method: string, args: Abs[] | (() => Abs[]), loc?: [number, number]): Abs;
 /** obj[key]()：计算键成员调用（键运行时求值）。键折叠成槽名后走 $invoke
  *  既有派发；@@iterator 键按接收者形态折迭代器对象。键不可折叠（抽象键 /
  *  用户 symbol）→ 诚实 unknown（与 $call 对 unknown callee 同口径——
- *  unknown 是 fail-closed 令牌，不记 may-throw）。 */
-declare function $invokeKey(thisVal: Abs, key: Abs, args: Abs[], loc?: [number, number]): Abs;
+ *  unknown 是 fail-closed 令牌，不记 may-throw）。
+ *  Bug 152：实参 thunk 形态（`() => [args]`）——键求值后**先读成员**再求
+ *  实参（原生顺序：键 → 引用取值 → 实参 → 调用）。 */
+declare function $invokeKey(thisVal: Abs, key: Abs, args: Abs[] | (() => Abs[]), loc?: [number, number]): Abs;
 /** 可选链计算键调用（a?.[k]() / a[k]?.() 的非链路径）：nullish 接收者
  *  短路 undefined 字面量（$optionalInvoke 同口径）；键折叠与派发同
  *  $invokeKey。 */
 declare function $optionalInvokeKey(thisVal: Abs, key: Abs, args: Abs[]): Abs;
 
 /**
- * this/可选链/静态成员读写：$thisGet/$thisSet/$optionalGet/$staticInvoke/$setKey。
+ * this/可选链/静态成员读写：$optionalGet/$staticInvoke/$setKey。
  *
  * Invariants:
- * - 类方法体内 this 成员读经 $thisGet（内层 obj 槽优先）；可选链臂
- *   （?.）已过 nullish 排除——不重复记 may-throw。
+ * - 可选链臂（?.）已过 nullish 排除——不重复记 may-throw。
  * - $setKey 计算键写：非字面量 key → open + index join（不得写成字面
  *   槽 "?"）；对象字面量计算键 __proto__ 是自有数据属性（与 $set 的
  *   setter 语义分流）。
  */
 
-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 字面量。非 nullish 臂的属性读对
- *  非 nullish 值原生不抛 → silent（不记 any may-throw，Bug 3） */
-declare function $optionalGet(o: Abs, key: string): Abs;
+ *  非 nullish 值原生不抛 → silent（不记 any may-throw，Bug 3）。
+ *  opts.symbolKey（Bug 149）：键来自符号投影（"[Symbol.X]" → "@@X"）——
+ *  陷阱边界把 "@@X" 还原成真 symbol（规范 PropertyKey）。 */
+declare function $optionalGet(o: Abs, key: string, opts?: {
+    symbolKey?: boolean;
+}): 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;
 
@@ -1092,4 +1629,4 @@ declare class NudoUnsupportedError extends Error {
     detail?: string);
 }
 
-export { $absVal, $add, $arguments, $arr, $arrMutContainer, $arrRest, $arrWithHoles, $async, $asyncReturn, $await, $bitand, $bitnot, $bitor, $bitxor, $catchVal, $class, $classExpr, $collectionForEach, $concat, $copy, $del, $delRes, $div, $dynamicImport, $elems, $eq, $eqLoose, $fnVal, $for, $forInKeys, $forIter, $forOf, $fork, $ge, $gen, $get, $getSuper, $getSuperObj, $gt, $idx, $idxSet, $importMeta, $in, $instanceof, $instanceofNonIdent, $invoke, $invokeKey, $invokeSuper, $invokeSuperKey, $invokeSuperObj, $isBreakTo, $isForkExit, $iterCheck, $join, $le, $len, $lit, $loopBreak, $loopContinue, $loopReturn, $lt, $mod, $mul, $narrowMemberEq, $narrowTypeOf, $ne, $neLoose, $neg, $new, $newTarget, $not, $nullishTest, $obj, $objAccessor, $objAccessorKey, $objRest, $optionalGet, $optionalInvoke, $optionalInvokeKey, $orDefault, $pow, $pushLoopExit, $rawThis, $reStateCall, $refineRel, $regex, $removeMemberNullish, $removeNull, $removeNullish, $removeUndefined, $restBind, $rethrowIfNudoReturn, $set, $setKey, $setProto, $setSuper, $setSuperObj, $setSuperStatic, $shl, $shr, $spread, $staticInit, $staticInvoke, $staticSuperInvoke, $sub, $super, $switch, $thisGet, $thisSet, $throw, $toNumber, $toNumeric, $tpl, $tryCurrentMark, $tryDetachSoftCatch, $tryDigestSoftCatch, $tryDiscardSoft, $tryMark, $tryOrphanSoft, $tryPopMark, $tryReleaseSoftCatch, $tryReleaseSoftOut, $tryTakeSince, $typeof, $unknown, $updateAdd, $updateSub, $ushr, $while, $whileSeq, $yield, $yieldStar, DEFAULT_MAX_LOOP_ITERS, type EvalClassSpec, NudoLoopSignal, NudoReturn, NudoThrow, NudoUnsupportedError, type TranspileOptions, asAbsVal, callAtFunctionBoundary, clearBClasses, clearStaleTermPred, currentAssumePremises, currentExecPhi, fillTuple, foldRequireSpecArg, foldStaticStringExpr, getEvalClass, isArrMutator, isDefinitelyFalse, isDefinitelyTrue, isNudoBreak, isNudoContinue, isNudoReturn, isNudoThrow, litTruth, lookupObjAccessor, namespaceNameOf, pushLoopExit, pushThrowExit, registerEvalClass, runWithLoopExits, runtimeImportOf, takeLoopExits, takeThrowExits, transpile, transpileBodyNode, transpileExpression, transpileFile, transpileSource, withAssumePremises, withExecPhi };
+export { $absVal, $add, $arguments, $arr, $arrMutContainer, $arrRest, $arrWithHoles, $assumeAnchor, $async, $asyncGen, $await, $bitand, $bitnot, $bitor, $bitxor, $catchReturn, $catchVal, $class, $classExpr, $collectionForEach, $concat, $copy, $del, $delRes, $div, $dynamicImport, $elems, $eq, $eqLoose, $fnKindStamp, $fnVal, $for, $forInKeys, $forOf, $fork, $ge, $gen, $get, $getSuper, $getSuperObj, $gt, $idx, $idxSet, $importMeta, $in, $instanceof, $instanceofNonIdent, $invoke, $invokeKey, $invokeSuper, $invokeSuperKey, $invokeSuperObj, $isBreakTo, $isForkExit, $iterCheck, $join, $le, $len, $lit, $litTruth, $loopBreak, $loopContinue, $loopReturn, $lt, $mod, $mul, $narrowMemberEq, $narrowTypeOf, $ne, $neLoose, $neg, $new, $newTarget, $not, $nullishTest, $obj, $objAccessor, $objAccessorKey, $objRest, $optionalGet, $optionalInvoke, $optionalInvokeKey, $orDefault, $pow, $pushLoopExit, $rawThis, $reStateCall, $refineRel, $regex, $removeMemberNullish, $removeNull, $removeNullish, $removeUndefined, $restBind, $rethrowIfNudoReturn, $set, $setKey, $setProto, $setSuper, $setSuperObj, $setSuperStatic, $shl, $shr, $spread, $staticSuperInvoke, $sub, $super, $switch, $throw, $throwConstAssign, $throwFreeArguments, $toNumber, $toNumeric, $tpl, $tryCurrentMark, $tryDetachSoftCatch, $tryDigestSoftCatch, $tryDiscardSoft, $tryMark, $tryOrphanSoft, $tryPopMark, $tryReleaseSoftCatch, $tryReleaseSoftOut, $tryTakeSince, $typeof, $unknown, $updateAdd, $updateSub, $ushr, $whileSeq, $yield, $yieldStar, DEFAULT_MAX_LOOP_ITERS, type EvalClassSpec, NudoLoopSignal, NudoReturn, NudoThrow, NudoUnsupportedError, RUNTIME_IMPORT_RE, type TranspileOptions, asAbsVal, callAtFunctionBoundary, clearBClasses, clearStaleTermPred, currentAssumePremises, currentExecPhi, fillTuple, foldRequireSpecArg, foldStaticStringExpr, getEvalClass, isArrMutator, isDefinitelyFalse, isDefinitelyTrue, isNudoBreak, isNudoContinue, isNudoReturn, isNudoThrow, litTruth, lookupObjAccessor, namespaceNameOf, pushLoopExit, pushThrowExit, registerEvalClass, runWithLoopExits, runtimeImportOf, takeLoopExits, takeThrowExits, transpile, transpileBodyNode, transpileExpression, transpileFile, transpileSource, withAssumePremises, withExecPhi };