@nudojs/core 1.16.0 → 1.17.1

package/dist/{chunk-POGFCYV2.js → chunk-G27PMV2U.js}

@@ -1,11 +1,13 @@
 import {
   $invoke,
   $new,
+  BoundedLruMap,
   CONSTRAINT_BUILDERS,
   DIAG,
   LAZY_TEMPLATE_DEPTH,
   TYPEOF_NAMES,
   abs,
+  absKey,
   absLit,
   and,
   andC,
@@ -32,6 +34,7 @@ import {
   freeIdentifiers,
   getFnImpl,
   getSlot,
+  hasUseStrictDirective,
   identBoundaryRegex,
   implies,
   instantiateConstraint,
@@ -50,10 +53,12 @@ import {
   numLit,
   pTrue,
   parseSource,
+  predKey,
   predToString,
   registerCollectorScopeParticipant,
   runTranspiledOptionsMemoKey,
   snapshotAbs,
+  sourceIsStrict,
   stripStringsKeepComments,
   termEquals,
   termToString,
@@ -65,7 +70,7 @@ import {
   withExecPhi,
   withFnBudgetOverride,
   withOptionalParams
-} from "./chunk-OM6SAY2M.js";
+} from "./chunk-CUFP2AYV.js";
 
 // src/algebra/directive-scan.ts
 function cleanDirectiveLine(raw, kind) {
@@ -617,8 +622,16 @@ function nestedBodyRanges(source) {
     return [];
   }
 }
+var BODY_GATE_RANGES_CACHE_MAX = 16;
+var bodyGateRangesCache = new BoundedLruMap(
+  BODY_GATE_RANGES_CACHE_MAX
+);
 function bodyGateRanges(source) {
-  return [...functionBodyRanges(source), ...nestedBodyRanges(source)];
+  const hit = bodyGateRangesCache.get(source);
+  if (hit !== void 0) return hit;
+  const out = [...functionBodyRanges(source), ...nestedBodyRanges(source)];
+  bodyGateRangesCache.set(source, out);
+  return out;
 }
 function inBodyRange(ranges, offset) {
   return ranges.some(([s, e]) => offset >= s && offset < e);
@@ -2380,7 +2393,27 @@ function extractFnBudget(source, fnName) {
 }
 
 // src/algebra/scan-named-exports.ts
+var LOCAL_EXPORTS_CACHE_MAX = 16;
+var localExportsCache = /* @__PURE__ */ new Map();
+function memoizedLocalExports(source, compute) {
+  const hit = localExportsCache.get(source);
+  if (hit !== void 0) {
+    localExportsCache.delete(source);
+    localExportsCache.set(source, hit);
+    return new Set(hit);
+  }
+  const out = compute();
+  if (localExportsCache.size >= LOCAL_EXPORTS_CACHE_MAX) {
+    const oldest = localExportsCache.keys().next().value;
+    if (oldest !== void 0) localExportsCache.delete(oldest);
+  }
+  localExportsCache.set(source, out);
+  return new Set(out);
+}
 function localNamedExports(source) {
+  return memoizedLocalExports(source, () => computeLocalNamedExports(source));
+}
+function computeLocalNamedExports(source) {
   const out = /* @__PURE__ */ new Set();
   let ast;
   try {
@@ -4031,87 +4064,8 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile, opts) {
 }
 
 // src/algebra/generalize-key.ts
-function termKey(t, rename) {
-  switch (t.op) {
-    case "lit":
-      return `L:${typeof t.value}:${litKeyString(t.value)}`;
-    case "var":
-      return `V:${rename?.get(t.id) ?? t.id}`;
-    case "app":
-      return `A:${t.fn}(${t.args.map((a) => termKey(a, rename)).join(",")})`;
-  }
-}
-function predKey(p, rename) {
-  switch (p.op) {
-    case "true":
-      return "T";
-    case "false":
-      return "F";
-    case "eq":
-    case "ne":
-    case "lt":
-    case "le":
-    case "gt":
-    case "ge":
-      return `${p.op}(${termKey(p.a, rename)},${termKey(p.b, rename)})`;
-    case "and":
-    case "or": {
-      const keys = p.args.map((a) => predKey(a, rename)).sort();
-      return `${p.op}(${keys.join(",")})`;
-    }
-    case "not":
-      return `not(${predKey(p.arg, rename)})`;
-    case "typeof":
-      return `typeof(${termKey(p.t, rename)},${p.type})`;
-    case "assumeFinite":
-      return `assumeFinite(${termKey(p.t, rename)})`;
-  }
-}
-function shapeKey(s, seen, rename) {
-  switch (s.k) {
-    case "never":
-    case "any":
-    case "unknown":
-      return s.k;
-    case "prim":
-      return `p:${s.type}`;
-    case "brand":
-      return `b:${s.name}(${absKeyInner(s.shape, seen, rename)})`;
-    case "eff":
-      return `e:${s.eff}<${absKeyInner(s.inner, seen, rename)}>`;
-    case "arr":
-      return `arr(${absKeyInner(s.element, seen, rename)})`;
-    case "tuple": {
-      const els = s.elements.map((e) => absKeyInner(e, seen, rename)).join(",");
-      const rest = s.rest ? `...${absKeyInner(s.rest, seen, rename)}` : "";
-      return `tup[${els}${rest}]`;
-    }
-    case "fn": {
-      const pts = (s.paramTypes ?? []).map((t) => absKeyInner(t, seen, rename)).join(",");
-      const ret = s.returnType ? absKeyInner(s.returnType, seen, rename) : "?";
-      const name = s.name ? `#${s.name}` : "";
-      return `fn${name}(${s.params.join(",")}|${pts})=>${ret}`;
-    }
-    case "sum":
-      return `sum(${s.members.map((m) => absKeyInner(m, seen, rename)).join("|")})`;
-    case "obj": {
-      const slots = Object.keys(s.slots).sort().map((k) => {
-        const slot = s.slots[k];
-        const flags = (slot.optional ? "?" : "") + (slot.readonly ? "r" : "");
-        return `${k}${flags}:${absKeyInner(slot.value, seen, rename)}`;
-      }).join(",");
-      const idx = s.index ? `idx(${absKeyInner(s.index.key, seen, rename)}\u2192${absKeyInner(s.index.value, seen, rename)})` : "";
-      const open = s.open ? "open" : "";
-      return `obj{${slots}}${idx}${open}`;
-    }
-  }
-}
 function absKeyInner(a, seen, rename) {
-  if (seen.has(a)) return "cycle";
-  seen.add(a);
-  const t = a.term ? `=${termKey(a.term, rename)}` : "";
-  const p = a.pred ? `@${predKey(a.pred, rename)}` : "";
-  return `${shapeKey(a.shape, seen, rename)}${t}${p}`;
+  return absKey(a, seen, rename);
 }
 function collectTermVars(t, acc) {
   if (t.op === "var") acc.add(t.id);
@@ -4239,43 +4193,58 @@ function renameShape(s, map) {
     case "prim":
       return s;
     case "brand":
-      return { k: "brand", name: s.name, shape: renameAbs(s.shape, map) };
-    case "eff":
-      return { k: "eff", eff: s.eff, inner: renameAbs(s.inner, map) };
+      return { ...s, shape: renameAbs(s.shape, map) };
+    case "eff": {
+      const out = { ...s, inner: renameAbs(s.inner, map) };
+      if (s.rejected) out.rejected = renameAbs(s.rejected, map);
+      return out;
+    }
     case "arr":
-      return { k: "arr", element: renameAbs(s.element, map) };
+      return { ...s, element: renameAbs(s.element, map) };
     case "tuple": {
       const out = {
-        k: "tuple",
+        ...s,
         elements: s.elements.map((e) => renameAbs(e, map))
       };
       if (s.rest) out.rest = renameAbs(s.rest, map);
+      if (s.holes) out.holes = [...s.holes];
       return out;
     }
     case "fn": {
-      const out = { k: "fn", params: s.params };
-      if (s.name !== void 0) out.name = s.name;
+      const out = { ...s, params: [...s.params] };
       if (s.paramTypes) out.paramTypes = s.paramTypes.map((t) => renameAbs(t, map));
       if (s.returnType) out.returnType = renameAbs(s.returnType, map);
-      if (s.ctor !== void 0) out.ctor = s.ctor;
+      if (s.optionalParams) out.optionalParams = [...s.optionalParams];
+      if (s.slots) {
+        const slots = {};
+        for (const [k, slot] of Object.entries(s.slots)) {
+          Object.defineProperty(slots, k, {
+            value: { ...slot, value: renameAbs(slot.value, map) },
+            enumerable: true,
+            writable: true,
+            configurable: true
+          });
+        }
+        out.slots = slots;
+      }
       return out;
     }
     case "sum":
-      return { k: "sum", members: s.members.map((m) => renameAbs(m, map)) };
+      return { ...s, members: s.members.map((m) => renameAbs(m, map)) };
     case "obj": {
       const slots = {};
       for (const [k, slot] of Object.entries(s.slots)) {
-        slots[k] = {
-          value: renameAbs(slot.value, map),
-          ...slot.optional ? { optional: true } : {},
-          ...slot.readonly ? { readonly: true } : {}
-        };
+        Object.defineProperty(slots, k, {
+          value: { ...slot, value: renameAbs(slot.value, map) },
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
       }
-      const out = { k: "obj", slots };
+      const out = { ...s, slots };
       if (s.index) {
         out.index = { key: renameAbs(s.index.key, map), value: renameAbs(s.index.value, map) };
       }
-      if (s.open) out.open = true;
       return out;
     }
   }
@@ -4306,6 +4275,130 @@ function alphaRenameResult(result, fromOrder, toOrder) {
   return renameAbs(result, map);
 }
 
+// src/algebra/generalize.ts
+import { VISITOR_KEYS } from "@babel/types";
+
+// src/algebra/memo-store.ts
+var DependencyMemo = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  values = /* @__PURE__ */ new Map();
+  keyDeps = /* @__PURE__ */ new Map();
+  depIndex = /* @__PURE__ */ new Map();
+  get size() {
+    return this.values.size;
+  }
+  /** 命中 ⇒ 移到队尾（LRU 刷新）；`hit` 区分存了 undefined 与 miss */
+  lookup(key) {
+    if (!this.values.has(key)) return { hit: false };
+    const value = this.values.get(key);
+    this.values.delete(key);
+    this.values.set(key, value);
+    return { hit: true, value };
+  }
+  set(key, value, depPaths) {
+    if (!this.values.has(key) && this.values.size >= this.max) {
+      const oldest = this.values.keys().next().value;
+      if (oldest !== void 0) {
+        this.values.delete(oldest);
+        this.unindex(oldest);
+      }
+    }
+    this.values.set(key, value);
+    if (depPaths.length > 0) {
+      const normDeps = [...new Set(depPaths.map(stablePathKey))];
+      this.keyDeps.set(key, normDeps);
+      for (const p of normDeps) {
+        let set = this.depIndex.get(p);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.depIndex.set(p, set);
+        }
+        set.add(key);
+      }
+    }
+  }
+  /** 定向逐出依赖这些路径的条目；返回删除数。查找与索引同走 stablePathKey */
+  evictForPaths(paths) {
+    let n = 0;
+    for (const raw of paths) {
+      const p = stablePathKey(raw);
+      const keys = this.depIndex.get(p);
+      if (!keys) continue;
+      for (const key of [...keys]) {
+        this.values.delete(key);
+        this.unindex(key);
+        n++;
+      }
+    }
+    return n;
+  }
+  reset() {
+    this.values.clear();
+    this.keyDeps.clear();
+    this.depIndex.clear();
+  }
+  unindex(key) {
+    const deps = this.keyDeps.get(key);
+    if (!deps) return;
+    for (const p of deps) {
+      const set = this.depIndex.get(p);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) this.depIndex.delete(p);
+    }
+    this.keyDeps.delete(key);
+  }
+};
+
+// src/algebra/memo-identity.ts
+var loadModuleIds = /* @__PURE__ */ new WeakMap();
+var nextLoadModuleId = 1;
+function loadModuleId(fn) {
+  if (!fn) return 0;
+  let id = loadModuleIds.get(fn);
+  if (id === void 0) {
+    id = nextLoadModuleId++;
+    loadModuleIds.set(fn, id);
+  }
+  return id;
+}
+var moduleMapIds = /* @__PURE__ */ new WeakMap();
+var moduleMapIdSeq = 0;
+function moduleMapId(m) {
+  if (!m) return "-";
+  let id = moduleMapIds.get(m);
+  if (id === void 0) {
+    id = ++moduleMapIdSeq;
+    moduleMapIds.set(m, id);
+  }
+  return `m${id}`;
+}
+
+// src/algebra/bridge-instance.ts
+function bareInstanceOf(clsAbs, clsName) {
+  const name = clsAbs.shape.k === "brand" && clsAbs.shape.name.length > 0 ? clsAbs.shape.name : clsName;
+  return abs(
+    {
+      k: "brand",
+      name,
+      shape: abs({ k: "unknown" }, void 0, void 0, "partial")
+    },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function instanceForMethodBridge(clsAbs, clsName, ctorArgs, isolate) {
+  try {
+    return isolate ? isolate(() => $new(clsAbs, ctorArgs)) : $new(clsAbs, ctorArgs);
+  } catch {
+    return bareInstanceOf(clsAbs, clsName);
+  }
+}
+
 // src/algebra/promote-scan.ts
 var HOF_ARR_METHODS = /* @__PURE__ */ new Set(["map", "filter", "reduce", "flatMap"]);
 function alphaOfTerm(t, ctx) {
@@ -4663,23 +4756,6 @@ function evalRunOf(source, modules, inject, scopeKey) {
   }
   return run;
 }
-function instanceForMethodBridge(clsAbs, clsName, ctorArgs) {
-  try {
-    return $new(clsAbs, ctorArgs);
-  } catch {
-    const name = clsAbs.shape.k === "brand" && clsAbs.shape.name.length > 0 ? clsAbs.shape.name : clsName;
-    return abs(
-      {
-        k: "brand",
-        name,
-        shape: abs({ k: "unknown" }, void 0, void 0, "partial")
-      },
-      void 0,
-      void 0,
-      "path"
-    );
-  }
-}
 function ctorParamCountOf(fileAst, clsName) {
   for (const stmt of fileAst.program.body) {
     if ((stmt.type === "ClassDeclaration" || stmt.type === "ExportNamedDeclaration") && "declaration" in stmt) {
@@ -4769,55 +4845,18 @@ function bodyReferencesName(body, name) {
   visit2(body);
   return found;
 }
-var generalizeMemo = /* @__PURE__ */ new Map();
-var memoKeyDeps = /* @__PURE__ */ new Map();
-var memoDepIndex = /* @__PURE__ */ new Map();
-var loadModuleIds = /* @__PURE__ */ new WeakMap();
-var nextLoadModuleId = 1;
 var MAX_GENERALIZE_MEMO = 1024;
+var generalizeMemo = new DependencyMemo(MAX_GENERALIZE_MEMO);
 function resetGeneralizeMemo() {
-  generalizeMemo.clear();
-  memoKeyDeps.clear();
-  memoDepIndex.clear();
+  generalizeMemo.reset();
   resetFnFpCache();
   resetHashSourceCache();
 }
 function getGeneralizeMemoSize() {
   return generalizeMemo.size;
 }
-function unindexMemoKey(key) {
-  const deps = memoKeyDeps.get(key);
-  if (!deps) return;
-  for (const p of deps) {
-    const set = memoDepIndex.get(p);
-    if (!set) continue;
-    set.delete(key);
-    if (set.size === 0) memoDepIndex.delete(p);
-  }
-  memoKeyDeps.delete(key);
-}
 function evictGeneralizeMemoForPaths(paths) {
-  let n = 0;
-  for (const raw of paths) {
-    const p = stablePathKey(raw);
-    const keys = memoDepIndex.get(p);
-    if (!keys) continue;
-    for (const key of [...keys]) {
-      generalizeMemo.delete(key);
-      unindexMemoKey(key);
-      n++;
-    }
-  }
-  return n;
-}
-function loadModuleId(fn) {
-  if (!fn) return 0;
-  let id = loadModuleIds.get(fn);
-  if (id === void 0) {
-    id = nextLoadModuleId++;
-    loadModuleIds.set(fn, id);
-  }
-  return id;
+  return generalizeMemo.evictForPaths(paths);
 }
 function refineDepsFingerprint(source, refine) {
   if (!refine?.loadModule || !refine.fromFile) {
@@ -4825,17 +4864,6 @@ function refineDepsFingerprint(source, refine) {
   }
   return loadModuleDepsFingerprint(source, refine.loadModule, refine.fromFile);
 }
-var moduleMapIds = /* @__PURE__ */ new WeakMap();
-var moduleMapIdSeq = 0;
-function moduleMapId(m) {
-  if (!m) return "-";
-  let id = moduleMapIds.get(m);
-  if (id === void 0) {
-    id = ++moduleMapIdSeq;
-    moduleMapIds.set(m, id);
-  }
-  return `m${id}`;
-}
 function generalizeMemoKey(fnName, source, opts) {
   const r = opts.refine;
   const budget = opts.budget ?? defaultLeakBudget;
@@ -4861,41 +4889,64 @@ function generalizeMemoKey(fnName, source, opts) {
   };
 }
 function generalizeMemoGet(key) {
-  if (!generalizeMemo.has(key)) return null;
-  const v2 = generalizeMemo.get(key);
-  generalizeMemo.delete(key);
-  generalizeMemo.set(key, v2);
-  return v2;
+  const hit = generalizeMemo.lookup(key);
+  return hit.hit ? hit.value : null;
 }
 function generalizeMemoSet(key, value, depPaths) {
-  if (generalizeMemo.size >= MAX_GENERALIZE_MEMO) {
-    const oldest = generalizeMemo.keys().next().value;
-    if (oldest !== void 0) {
-      generalizeMemo.delete(oldest);
-      unindexMemoKey(oldest);
-    }
-  }
-  generalizeMemo.set(key, value);
-  if (depPaths.length > 0) {
-    const normDeps = [...new Set(depPaths.map(stablePathKey))];
-    memoKeyDeps.set(key, normDeps);
-    for (const p of normDeps) {
-      let set = memoDepIndex.get(p);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        memoDepIndex.set(p, set);
-      }
-      set.add(key);
-    }
-  }
+  generalizeMemo.set(key, value, depPaths);
 }
 function isCacheableAbs(a) {
   return a.conf === "exact" || a.conf === "path" || a.conf === "widened" || a.conf === "mock";
 }
+var strictRegionCache = /* @__PURE__ */ new WeakMap();
+function strictRegionsOf(file) {
+  const cached = strictRegionCache.get(file);
+  if (cached !== void 0) return cached;
+  const out = [];
+  const add = (n) => {
+    if (typeof n.start === "number" && typeof n.end === "number") {
+      out.push({ start: n.start, end: n.end });
+    }
+  };
+  const walk = (n) => {
+    if (n.type === "ClassDeclaration" || n.type === "ClassExpression") {
+      add(n);
+      return;
+    }
+    if (n.type === "BlockStatement" && hasUseStrictDirective(n)) {
+      add(n);
+      return;
+    }
+    for (const key of VISITOR_KEYS[n.type] ?? []) {
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const c of child) {
+          if (c && typeof c === "object" && typeof c.type === "string") {
+            walk(c);
+          }
+        }
+      } else if (child && typeof child === "object") {
+        if (typeof child.type === "string") walk(child);
+      }
+    }
+  };
+  walk(file);
+  strictRegionCache.set(file, out);
+  return out;
+}
 function extractFn(source, fnName, fileAst) {
   const file = fileAst ?? parseSource(source);
   const env = emptyEnv();
   const formalsByName = /* @__PURE__ */ new Map();
+  const fnStrict = sourceIsStrict(source, file);
+  const strictRegions = fnStrict ? [] : strictRegionsOf(file);
+  const inStrictRegion = (node) => {
+    const start = node.start;
+    const end = node.end;
+    if (typeof start !== "number" || typeof end !== "number") return false;
+    return strictRegions.some((r) => start >= r.start && end <= r.end);
+  };
+  const entryStrict = (body) => fnStrict || hasUseStrictDirective(body) || inStrictRegion(body);
   for (const stmt of file.program.body) {
     let decl = stmt;
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
@@ -4912,7 +4963,8 @@ function extractFn(source, fnName, fileAst) {
         // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
         optionalParams: formals.map((f) => f.optional === true),
         body: decl.body,
-        async: decl.async === true
+        async: decl.async === true,
+        strict: entryStrict(decl.body)
       });
       formalsByName.set(decl.id.name, formals);
       if (stmt.type === "ExportDefaultDeclaration") {
@@ -4940,7 +4992,10 @@ function extractFn(source, fnName, fileAst) {
           // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
           optionalParams: formals.map((f) => f.optional === true),
           body: mem.body,
-          async: mem.async === true
+          async: mem.async === true,
+          // class 体恒 strict（原生：类定义整体是 strict mode code，与所在
+          // 文件种类无关）⇒ 方法体内的块级函数声明不得 Annex B 提升。
+          strict: true
         });
         formalsByName.set(fullName, formals);
       }
@@ -4956,7 +5011,8 @@ function extractFn(source, fnName, fileAst) {
             // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
             optionalParams: formals.map((f) => f.optional === true),
             body: init.body,
-            async: init.async === true
+            async: init.async === true,
+            strict: entryStrict(init.body)
           });
           formalsByName.set(d.id.name, formals);
         }
@@ -4971,7 +5027,8 @@ function extractFn(source, fnName, fileAst) {
         // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
         optionalParams: formals.map((f) => f.optional === true),
         body: init.body,
-        async: init.async === true
+        async: init.async === true,
+        strict: entryStrict(init.body)
       });
       formalsByName.set("default", formals);
     }
@@ -4988,7 +5045,9 @@ function extractFn(source, fnName, fileAst) {
       // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
       optionalParams: formals.map((f) => f.optional === true),
       body: node.body,
-      async: node.async === true
+      async: node.async === true,
+      // ClassMethod（防御面）恒 strict；其余按源级 ∨ 函数体指令 ∨ 严格区继承。
+      strict: node.type === "ClassMethod" ? true : entryStrict(node.body)
     });
     formalsByName.set(key, formals);
   };
@@ -5069,6 +5128,7 @@ function extractFn(source, fnName, fileAst) {
     if ((n.type === "ClassMethod" || n.type === "ClassPrivateMethod" || n.type === "ObjectMethod") && n.kind && n.kind !== "method") {
       continue;
     }
+    const isClassMethod = n.type === "ClassMethod" || n.type === "ClassPrivateMethod";
     const formals = formalParamsFromNodes(n.params ?? []);
     env.fns.set(scope.name, {
       params: formalParamDisplayNames(formals),
@@ -5076,7 +5136,8 @@ function extractFn(source, fnName, fileAst) {
       // 不再靠名字后缀猜（默认形参渲染成光秃秃的名字 ⇒ 被计成必选）
       optionalParams: formals.map((f) => f.optional === true),
       body: n.body,
-      async: n.async === true
+      async: n.async === true,
+      strict: isClassMethod ? true : entryStrict(n.body)
     });
     formalsByName.set(scope.name, formals);
   }
@@ -5279,7 +5340,8 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
   const boundNames = formals.flatMap(
     (f) => f.kind === "pattern" ? f.bound : [f.name]
   );
-  const envGated = envGatedSource && freeIdentifiers(body, boundNames).size > 0;
+  const fnBodyStrict = env.fns.get(fnName)?.strict === true;
+  const envGated = envGatedSource && freeIdentifiers(body, boundNames, fnBodyStrict).size > 0;
   const replaceGated = /@nudo:replace\b/.test(directiveSrc) && !hasReps;
   const evalEligible = !unresolvableImports && !mockGated && !envGated && !replaceGated;
   const fnBudget = extractFnBudget(source, fnName);
@@ -5322,7 +5384,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
           }
           return a;
         });
-        return callTranspiledExportFull(evalRun, fnName, evalArgs, { phi }).result;
+        return callTranspiledExportFull(evalRun, fnName, evalArgs, { phi, preferLocal: true }).result;
       } else {
         const slot = resolveExportSlotCall(fileAst, fnName, evalRun);
         if (!slot) return void 0;
@@ -5340,7 +5402,10 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
           if (dAbs.shape.k !== "obj") return void 0;
           return withExecPhi(phi, () => $invoke(dAbs, slot.member, evalArgs));
         }
-        return callTranspiledExportFull(evalRun, slot.key, evalArgs, { phi }).result;
+        return callTranspiledExportFull(evalRun, slot.key, evalArgs, {
+          phi,
+          preferLocal: true
+        }).result;
       }
     } catch (e) {
       noteEvalFallback(e);
@@ -5462,26 +5527,6 @@ function formatPoly(name, renderNames, params, typeParams, symbolic, entryReqs,
   const predPart = symbolic.pred && symbolic.pred.op !== "true" ? `  where ${predToString(symbolic.pred)}` : "";
   return `${name}: (${ps}) => ${ret}${predPart}`;
 }
-function generalizeAll(source, opts = {}) {
-  const file = parseSource(source);
-  const names = [];
-  for (const stmt of file.program.body) {
-    if (stmt.type === "FunctionDeclaration" && stmt.id) names.push(stmt.id.name);
-    if (stmt.type === "VariableDeclaration") {
-      for (const d of stmt.declarations) {
-        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
-          names.push(d.id.name);
-        }
-      }
-    }
-  }
-  const out = [];
-  for (const n of names) {
-    const g = generalizeFromAst(n, source, opts);
-    if (g) out.push(g);
-  }
-  return out;
-}
 function listFunctionNames(source) {
   const file = parseSource(source);
   const names = [];
@@ -7282,8 +7327,22 @@ function defaultArgAbss(fnName, source, fileAst, lookupVar) {
   return { values: out, defaulted };
 }
 
+// src/algebra/scan/path-projection.ts
+function projectAbsPath(arg, segments) {
+  let cur = arg;
+  for (const seg of segments) {
+    if (!cur) return void 0;
+    if (cur.shape.k === "brand") {
+      cur = cur.shape.shape;
+    }
+    if (cur.shape.k !== "obj") return void 0;
+    cur = getSlot(cur.shape.slots, seg)?.value;
+  }
+  return cur;
+}
+
 // src/algebra/scan/literal-preds.ts
-function isExactUndef(a) {
+function isNullishLitAbs(a) {
   return a.term?.op === "lit" && (a.term.value === void 0 || a.term.value === null);
 }
 function nullishKindOf(a) {
@@ -7405,7 +7464,7 @@ function argTypeofName(arg) {
   if (sh.k === "prim") return sh.type;
   if (sh.k === "obj" || sh.k === "arr" || sh.k === "tuple") return "object";
   if (sh.k === "fn") return "function";
-  return isExactUndef(arg) ? "undefined" : void 0;
+  return isNullishLitAbs(arg) ? "undefined" : void 0;
 }
 function predOnVar(p) {
   switch (p.op) {
@@ -7495,18 +7554,6 @@ function judgeOrUnion(or, arg, argLen) {
   if (undecided) return void 0;
   return hasFalse ? false : void 0;
 }
-function projectArgPath(arg, segments) {
-  let cur = arg;
-  for (const seg of segments) {
-    if (!cur) return void 0;
-    if (cur.shape.k === "brand") {
-      cur = cur.shape.shape;
-    }
-    if (cur.shape.k !== "obj") return void 0;
-    cur = getSlot(cur.shape.slots, seg)?.value;
-  }
-  return cur;
-}
 function checkReqs(ctx, displayName, reqs, paramNames, absArgs, argIndexOf, loc, skipParams) {
   const out = ctx.out;
   for (const [idx, pred, fieldPath, contractParam, rest] of reqs) {
@@ -7518,7 +7565,7 @@ function checkReqs(ctx, displayName, reqs, paramNames, absArgs, argIndexOf, loc,
     if (rest) arg = restArgAbs(absArgs.slice(argIdx));
     const paramName = contractParam || paramNames[idx] || `arg${idx}`;
     if (fieldPath) {
-      const projected = projectArgPath(arg, fieldPath);
+      const projected = projectAbsPath(arg, fieldPath);
       if (!projected) {
         const k = arg.shape.k;
         if (k !== "unknown" && k !== "any") {
@@ -7543,7 +7590,7 @@ function checkReqs(ctx, displayName, reqs, paramNames, absArgs, argIndexOf, loc,
     const lv = lvR.ok ? lvR.value : void 0;
     const isStr = arg.shape.k === "prim" && arg.shape.type === "string";
     const argLen = typeof lv === "string" ? lv.length : arrayLengthOf(arg);
-    const argIsUndef = isExactUndef(arg);
+    const argIsUndef = isNullishLitAbs(arg);
     const flat = flattenPred(pred);
     const hasVarTypeof = flat.some((q) => q.op === "typeof" && q.t.op === "var");
     let typeofReported = false;
@@ -7955,7 +8002,7 @@ function checkShapeReqs(ctx, displayName, reqs, paramNames, absArgs, argIndexOf,
     }
     const paramName = entry.param || paramNames[idx] || `arg${idx}`;
     if (fieldPath) {
-      const projected = projectArgPath(arg, fieldPath);
+      const projected = projectAbsPath(arg, fieldPath);
       if (!projected) {
         continue;
       }
@@ -7996,7 +8043,7 @@ function checkShapeReqs(ctx, displayName, reqs, paramNames, absArgs, argIndexOf,
             restAgg
           );
         });
-      } else if (isExactUndef(arg) || arg.shape.k !== "unknown" && arg.shape.k !== "any") {
+      } else if (isNullishLitAbs(arg) || arg.shape.k !== "unknown" && arg.shape.k !== "any") {
         out.push({
           severity: "error",
           code: DIAG.constraintViolated,
@@ -9018,6 +9065,10 @@ export {
   extractAllLoadSpecs,
   sidecarSpecsOf,
   loadModuleDepsFingerprint,
+  DependencyMemo,
+  loadModuleId,
+  moduleMapId,
+  instanceForMethodBridge,
   resolveExportSlotCall,
   collectAbsFreeVars,
   ctorParamCountOf,
@@ -9026,7 +9077,6 @@ export {
   evictGeneralizeMemoForPaths,
   extractFn,
   generalizeFromAst,
-  generalizeAll,
   listFunctionNames,
   buildArgsFromAssume,
   checkArg,
@@ -9036,6 +9086,7 @@ export {
   guardLoadModule,
   listTopFunctions,
   listClassEntryNames,
+  projectAbsPath,
   scanLiteralCalls,
   checkInjectedDomainEvidence,
   absWithStableTermIds,