@nudojs/core 1.2.2 → 1.4.0

package/dist/{chunk-TOURNNEA.js → chunk-7QUVTEYZ.js}

@@ -21,6 +21,7 @@ import {
   getFnImpl,
   getSlot,
   gt,
+  identBoundaryRegex,
   joinAbs,
   le,
   lit,
@@ -36,12 +37,704 @@ import {
   ptypeof,
   runTranspiledOptionsMemoKey,
   snapshotAbs,
+  stripStringsKeepComments,
   termToString,
   tryRunTranspiled,
   unknown,
   v,
-  withExecPhi
-} from "./chunk-4V3CRVSD.js";
+  withEvalBudgetOverride,
+  withExecPhi,
+  withFnBudgetOverride
+} from "./chunk-LFCF6BLE.js";
+
+// src/algebra/directive-scan.ts
+function cleanDirectiveLine(raw, kind) {
+  let s = raw;
+  if (kind === "block") {
+    s = s.replace(/^\s*\*\s?/, "");
+  } else {
+    s = s.replace(/^\//, "");
+  }
+  return s.trim();
+}
+function commentTextToLines(text, kind) {
+  return text.split("\n").map((line) => cleanDirectiveLine(line, kind));
+}
+function commentKind(c) {
+  return c.type === "CommentLine" ? "line" : "block";
+}
+function buildScope(name, node, wrapper, comments, wrapperComments) {
+  const seen = /* @__PURE__ */ new Set();
+  const texts = [];
+  const startLines = [];
+  const lines = [];
+  for (const c of [...wrapperComments ?? [], ...comments ?? []]) {
+    if (seen.has(c)) continue;
+    seen.add(c);
+    texts.push(c.value);
+    startLines.push(c.loc?.start?.line ?? 0);
+    for (const line of commentTextToLines(c.value, commentKind(c))) lines.push(line);
+  }
+  const loc = node.loc;
+  return {
+    name,
+    node,
+    commentTexts: texts,
+    commentLines: lines,
+    commentStartLines: startLines,
+    startLine: loc?.start?.line ?? 0
+  };
+}
+function isFnExpr(n) {
+  return !!n && (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression" || n.type === "FunctionDeclaration");
+}
+function keyNameOf(key) {
+  if (!key) return void 0;
+  const k = key;
+  if (k.type === "Identifier") return k.name;
+  if (k.type === "StringLiteral" || k.type === "NumericLiteral") return String(k.value);
+  return void 0;
+}
+function listFnDirectiveScopes(file) {
+  const out = [];
+  const pushNamedFn = (name, fnNode, commentNode, wrapper) => {
+    out.push(
+      buildScope(
+        name,
+        fnNode,
+        wrapper,
+        commentNode?.leadingComments,
+        wrapper?.leadingComments
+      )
+    );
+  };
+  const visit2 = (node, ctx) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    switch (n.type) {
+      case "File":
+        visit2(n.program, ctx);
+        return;
+      case "Program": {
+        for (const s of n.body ?? []) visit2(s, ctx);
+        return;
+      }
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration": {
+        const decl = n.declaration;
+        if (!decl) return;
+        const wrapCtx = { ...ctx, wrapperNode: node };
+        visitWithWrapper(decl, node, wrapCtx);
+        return;
+      }
+      case "FunctionDeclaration": {
+        const name = n.id?.name ?? ctx.fallbackName ?? "<anonymous>";
+        pushNamedFn(name, node, node, ctx.wrapperNode);
+        visit2(n.body, { owner: name });
+        return;
+      }
+      case "FunctionExpression": {
+        const name = n.id?.name ?? ctx.fallbackName ?? "<anonymous>";
+        pushNamedFn(name, node, node, ctx.wrapperNode);
+        visit2(n.body, { owner: name });
+        return;
+      }
+      case "ArrowFunctionExpression": {
+        const name = ctx.fallbackName ?? "<anonymous>";
+        pushNamedFn(name, node, ctx.commentHost ?? node, ctx.wrapperNode);
+        visit2(n.body, { owner: name });
+        return;
+      }
+      case "VariableDeclaration": {
+        for (const d of n.declarations ?? []) {
+          const decl = d;
+          const idName = decl.id?.type === "Identifier" ? decl.id.name : void 0;
+          if (isFnExpr(decl.init)) {
+            const fn2 = decl.init;
+            const scope = buildScope(
+              idName ?? "<anonymous>",
+              fn2,
+              ctx.wrapperNode,
+              node.leadingComments,
+              ctx.wrapperNode?.leadingComments
+            );
+            out.push(scope);
+            visit2(fn2, { owner: idName });
+          } else {
+            visit2(decl.init, { owner: idName, commentHost: node, wrapperNode: ctx.wrapperNode });
+          }
+        }
+        return;
+      }
+      case "ClassDeclaration":
+      case "ClassExpression": {
+        const cname = n.id?.name ?? ctx.fallbackName ?? "<anonymous>";
+        if (n.type === "ClassDeclaration") {
+        }
+        const body = n.body?.body ?? [];
+        for (const m of body) visit2(m, { owner: cname });
+        return;
+      }
+      case "ClassMethod":
+      case "ClassPrivateMethod":
+      case "ObjectMethod": {
+        const key = keyNameOf(n.key);
+        const owner = ctx.owner;
+        const name = key ? owner ? `${owner}.${key}` : key : "<anonymous>";
+        pushNamedFn(name, node, node, void 0);
+        visit2(n.body, { owner: name });
+        return;
+      }
+      case "ObjectProperty":
+      case "ClassProperty":
+      case "ClassPrivateProperty": {
+        const key = keyNameOf(n.key);
+        const val = n.value ?? n.init;
+        if (isFnExpr(val)) {
+          const owner = ctx.owner;
+          const name = key ? owner ? `${owner}.${key}` : key : "<anonymous>";
+          out.push(
+            buildScope(
+              name,
+              val,
+              void 0,
+              val.leadingComments ?? node.leadingComments,
+              void 0
+            )
+          );
+          visit2(val, { owner: name });
+          return;
+        }
+        visit2(val, ctx);
+        return;
+      }
+      case "ReturnStatement":
+      case "ThrowStatement":
+      case "AwaitExpression":
+      case "SpreadElement":
+      case "RestElement":
+        visit2(n.argument, ctx);
+        return;
+      case "UnaryExpression":
+      case "UpdateExpression":
+        visit2(n.argument, ctx);
+        return;
+      case "BinaryExpression":
+      case "LogicalExpression":
+      case "AssignmentExpression":
+        visit2(n.left, ctx);
+        visit2(n.right, ctx);
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visit2(n.object, ctx);
+        visit2(n.property, ctx);
+        return;
+      case "CallExpression":
+      case "OptionalCallExpression":
+      case "NewExpression": {
+        visit2(n.callee, ctx);
+        for (const a of n.arguments ?? []) visit2(a, ctx);
+        return;
+      }
+      case "ConditionalExpression":
+        visit2(n.test, ctx);
+        visit2(n.consequent, ctx);
+        visit2(n.alternate, ctx);
+        return;
+      case "ArrayExpression": {
+        for (const e of n.elements ?? []) visit2(e, ctx);
+        return;
+      }
+      case "ObjectExpression": {
+        for (const p of n.properties ?? []) visit2(p, ctx);
+        return;
+      }
+      case "SequenceExpression": {
+        for (const e of n.expressions ?? []) visit2(e, ctx);
+        return;
+      }
+      case "ParenthesizedExpression":
+        visit2(n.expression, ctx);
+        return;
+      case "ExpressionStatement":
+        visit2(n.expression, ctx);
+        return;
+      case "BlockStatement": {
+        for (const s of n.body ?? []) visit2(s, ctx);
+        return;
+      }
+      case "IfStatement":
+        visit2(n.test, ctx);
+        visit2(n.consequent, ctx);
+        visit2(n.alternate, ctx);
+        return;
+      case "ForStatement":
+        visit2(n.init, ctx);
+        visit2(n.test, ctx);
+        visit2(n.update, ctx);
+        visit2(n.body, ctx);
+        return;
+      case "ForInStatement":
+      case "ForOfStatement":
+        visit2(n.left, ctx);
+        visit2(n.right, ctx);
+        visit2(n.body, ctx);
+        return;
+      case "WhileStatement":
+      case "DoWhileStatement":
+        visit2(n.test, ctx);
+        visit2(n.body, ctx);
+        return;
+      case "TryStatement":
+        visit2(n.block, ctx);
+        visit2(n.handler, ctx);
+        visit2(n.finalizer, ctx);
+        return;
+      case "CatchClause":
+        visit2(n.body, ctx);
+        return;
+      case "SwitchStatement":
+        visit2(n.discriminant, ctx);
+        for (const c of n.cases ?? []) visit2(c, ctx);
+        return;
+      case "SwitchCase":
+        visit2(n.test, ctx);
+        for (const s of n.consequent ?? []) visit2(s, ctx);
+        return;
+      case "LabeledStatement":
+        visit2(n.body, ctx);
+        return;
+      default: {
+        for (const key of [
+          "body",
+          "expression",
+          "init",
+          "value",
+          "argument",
+          "declaration",
+          "left",
+          "right",
+          "test",
+          "consequent",
+          "alternate",
+          "block",
+          "handler",
+          "finalizer",
+          "callee",
+          "object",
+          "property",
+          "argument"
+        ]) {
+          const v2 = n[key];
+          if (Array.isArray(v2)) v2.forEach((x) => visit2(x, ctx));
+          else if (v2 && typeof v2 === "object" && "type" in v2) visit2(v2, ctx);
+        }
+        for (const key of ["declarations", "properties", "elements", "arguments", "cases", "params"]) {
+          const v2 = n[key];
+          if (Array.isArray(v2)) v2.forEach((x) => visit2(x, ctx));
+        }
+        return;
+      }
+    }
+  };
+  const visitWithWrapper = (decl, wrapper, ctx) => {
+    const d = decl;
+    if (d.type === "FunctionDeclaration" || d.type === "FunctionExpression") {
+      const name = d.id?.name ?? "default";
+      pushNamedFn(name, decl, decl, wrapper);
+      visit2(d.body, { owner: name });
+      return;
+    }
+    if (d.type === "ClassDeclaration" || d.type === "ClassExpression") {
+      const cname = d.id?.name ?? "<anonymous>";
+      const body = d.body?.body ?? [];
+      for (const m of body) visit2(m, { owner: cname });
+      return;
+    }
+    if (d.type === "VariableDeclaration") {
+      for (const raw of d.declarations ?? []) {
+        const vd = raw;
+        const idName = vd.id?.type === "Identifier" ? vd.id.name : void 0;
+        if (isFnExpr(vd.init)) {
+          const fn2 = vd.init;
+          out.push(
+            buildScope(
+              idName ?? "default",
+              fn2,
+              wrapper,
+              d.leadingComments,
+              wrapper.leadingComments
+            )
+          );
+          visit2(fn2, { owner: idName });
+        } else {
+          visit2(vd.init, {
+            owner: idName,
+            commentHost: decl,
+            wrapperNode: wrapper
+          });
+        }
+      }
+      return;
+    }
+    if (d.type === "ArrowFunctionExpression" || d.type === "FunctionExpression") {
+      const name = "default";
+      out.push(
+        buildScope(
+          name,
+          decl,
+          wrapper,
+          d.leadingComments,
+          wrapper.leadingComments
+        )
+      );
+      visit2(d.body, { owner: name });
+      return;
+    }
+    visit2(decl, { ...ctx, wrapperNode: wrapper });
+  };
+  for (const stmt of file.program.body) {
+    visit2(stmt, {});
+  }
+  return out;
+}
+function findFnDirectiveScope(file, fnName) {
+  return listFnDirectiveScopes(file).find((s) => s.name === fnName);
+}
+function fnDirectiveCommentLines(source, fnName) {
+  let file;
+  try {
+    file = parseSource(source);
+  } catch {
+    return [];
+  }
+  return findFnDirectiveScope(file, fnName)?.commentLines ?? [];
+}
+var isPathLikeEnv = (s) => /^[^\s]+$/.test(s) && (s.startsWith("./") || s.startsWith("../") || s.startsWith("/") || /\.(ts|js|mjs|cjs|tsx|jsx)$/.test(s));
+function parseEnvPayload(payload) {
+  return payload.split(",").map((e) => e.trim().replace(/^['"]|['"]$/g, "")).filter((e) => e && (/^\w+$/.test(e) || isPathLikeEnv(e)));
+}
+function parseMockModulePayload(payload) {
+  const partial2 = payload.match(/^\s*"([^"]+)"\s*\{([^}]+)\}\s*from\s*"([^"]+)"\s*$/);
+  if (partial2) {
+    const names = partial2[2].split(",").map((n) => n.trim()).filter(Boolean);
+    return { source: partial2[1], names, fromPath: partial2[3] };
+  }
+  const full = payload.match(/^\s*"([^"]+)"\s+from\s*"([^"]+)"\s*$/);
+  if (full) {
+    return { source: full[1], fromPath: full[2] };
+  }
+  return void 0;
+}
+function parseNudoImportPayload(payload) {
+  const s = payload.trim();
+  if (s === "") return void 0;
+  const named = s.match(/^\{([^}]+)\}\s*from\s*["']([^"']+)["']$/);
+  if (named) {
+    const names = named[1].split("\n").map((line) => line.replace(/^\s*\/\/\/?\s?/, "").trim()).join("\n").split(",").map((x) => x.trim()).filter(Boolean).map((x) => x.split(/\s+as\s+/).pop().trim());
+    return { names, spec: named[2] };
+  }
+  const ns = s.match(/^\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']$/);
+  if (ns) {
+    return { names: [`*${ns[1]}`], spec: ns[2] };
+  }
+  if (/^[\w$]+\s+from\b/.test(s) || /^[\w$]+\s*,/.test(s)) return "malformed-default";
+  return "malformed";
+}
+var LINE_COMMENT_PREFIX = "(?:^|[^/:])\\/\\/\\/?";
+function fileDirectiveVisibleText(source) {
+  return stripStringsKeepComments(source).replace(/\/\*[\s\S]*?\*\//g, " ");
+}
+function extractFileEnvNames(source) {
+  const text = fileDirectiveVisibleText(source);
+  const re = new RegExp(`${LINE_COMMENT_PREFIX}\\s*@nudo:env\\s+([^\\n*]+)`, "g");
+  const out = [];
+  let m;
+  while (m = re.exec(text)) {
+    out.push(...parseEnvPayload(m[1]));
+  }
+  return out;
+}
+function extractMockModuleRecords(source) {
+  const text = fileDirectiveVisibleText(source);
+  const re = new RegExp(
+    `${LINE_COMMENT_PREFIX}\\s*@nudo:mock-module\\s+([^\\n]+)`,
+    "g"
+  );
+  const out = [];
+  let m;
+  while (m = re.exec(text)) {
+    const rec = parseMockModulePayload(m[1]);
+    if (rec) out.push(rec);
+  }
+  return out;
+}
+function directiveCommentLinesRaw(source) {
+  const src = stripStringsKeepComments(source);
+  const out = [];
+  const lineRe = /(?:^|[^/:])\/\/\/?([^\n]*)/g;
+  let m;
+  while (m = lineRe.exec(src)) {
+    out.push(cleanDirectiveLine(m[1], "line"));
+  }
+  const blockRe = /\/\*([\s\S]*?)\*\//g;
+  while (m = blockRe.exec(src)) {
+    out.push(...commentTextToLines(m[1], "block"));
+  }
+  return out;
+}
+function nudoImportPayloads(source) {
+  const lines = directiveCommentLinesRaw(source);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!/^@nudo:import\s/.test(line)) continue;
+    let payload = line.replace(/^@nudo:import\s+/, "");
+    if (payload.startsWith("{")) {
+      let depth = 0;
+      for (const ch of payload) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      while (depth > 0 && i + 1 < lines.length) {
+        i += 1;
+        const cont = lines[i];
+        if (/^@nudo:/.test(cont)) {
+          i -= 1;
+          break;
+        }
+        payload += `
+${cont}`;
+        for (const ch of cont) {
+          if (ch === "{") depth++;
+          else if (ch === "}") depth--;
+        }
+      }
+    }
+    out.push(payload);
+  }
+  return out;
+}
+function extractNudoImportRecords(source) {
+  const out = [];
+  for (const payload of nudoImportPayloads(source)) {
+    const rec = parseNudoImportPayload(payload);
+    if (rec && rec !== "malformed" && rec !== "malformed-default") out.push(rec);
+  }
+  return out;
+}
+function scanMalformedNudoImports(source) {
+  const out = [];
+  for (const payload of nudoImportPayloads(source)) {
+    const rec = parseNudoImportPayload(payload);
+    if (rec === "malformed-default" || rec === "malformed") out.push(rec);
+  }
+  return out;
+}
+function extractBalancedParens(text, startIdx) {
+  if (text[startIdx] !== "(") return null;
+  let depth = 0;
+  let inString = null;
+  for (let i = startIdx; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (depth === 0) return text.slice(startIdx + 1, i);
+  }
+  return null;
+}
+var CASE_NAME_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/\/\/?\s*)?@nudo:case\s+"([^"]+)"\s*\(/g;
+function extractCaseExpectedExpr(text, afterParen) {
+  const lines = text.slice(afterParen).split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (i > 0) line = line.replace(/^\s*\*\s?/, "").replace(/^\s*\/\/\/?\s?/, "");
+    if (/^\s*@nudo:/.test(line)) return void 0;
+    const arrow = line.match(/^\s*=>\s*(\S.*)$/);
+    if (arrow) return arrow[1].trim();
+    if (line.trim() !== "") return void 0;
+  }
+  return void 0;
+}
+function scanCaseTags(text) {
+  const caseArgSpans = [];
+  const out = [];
+  CASE_NAME_REGEX.lastIndex = 0;
+  let m;
+  while ((m = CASE_NAME_REGEX.exec(text)) !== null) {
+    const parenStart = m.index + m[0].length - 1;
+    const argsStr = extractBalancedParens(text, parenStart);
+    if (argsStr === null) continue;
+    const afterParen = parenStart + argsStr.length + 2;
+    if (caseArgSpans.some(([s, e]) => m.index >= s && m.index < e)) continue;
+    caseArgSpans.push([m.index, afterParen]);
+    const tagOffset = m.index + m[0].indexOf("@nudo:case");
+    const expectedText = extractCaseExpectedExpr(text, afterParen);
+    out.push({ name: m[1], argsText: argsStr, expectedText, tagOffset });
+  }
+  return out;
+}
+function scanCaseArgSpans(text) {
+  const spans = [];
+  CASE_NAME_REGEX.lastIndex = 0;
+  let m;
+  while ((m = CASE_NAME_REGEX.exec(text)) !== null) {
+    const parenStart = m.index + m[0].length - 1;
+    const argsStr = extractBalancedParens(text, parenStart);
+    if (argsStr === null) continue;
+    const afterParen = parenStart + argsStr.length + 2;
+    if (spans.some(([s, e]) => m.index >= s && m.index < e)) continue;
+    spans.push([m.index, afterParen]);
+  }
+  return spans;
+}
+function scanContractSegments(lines) {
+  const reqs = [];
+  for (const line of lines) {
+    const m = line.match(/^@nudo:contract\s+(.+)$/);
+    if (m) reqs.push(m[1].trim().replace(/\*\/$/, "").trim());
+  }
+  return reqs;
+}
+function scanThrowsDecl(lines) {
+  const kinds = /* @__PURE__ */ new Set();
+  let any2 = false;
+  for (const line of lines) {
+    const th = line.match(/^@nudo:throws\s+(.+)$/i);
+    if (th) {
+      const spec = th[1].trim();
+      if (spec === "*") any2 = true;
+      else {
+        for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
+          if (k === "*") any2 = true;
+          else kinds.add(k);
+        }
+      }
+    }
+    const cs = line.match(/!!\s*throws(?:\s+([A-Za-z*][\w*|,\s]*))?/i);
+    if (cs) {
+      const spec = (cs[1] ?? "*").trim();
+      if (spec === "" || spec === "*") any2 = true;
+      else {
+        for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
+          if (k === "*") any2 = true;
+          else kinds.add(k);
+        }
+      }
+    }
+  }
+  if (any2) return "*";
+  if (kinds.size > 0) return [...kinds].join(",");
+  return void 0;
+}
+function scanBudgetDecl(lines) {
+  const out = {};
+  for (const line of lines) {
+    const bd = line.match(/^@nudo:budget\s+(.+)$/i);
+    if (!bd) continue;
+    for (const part of bd[1].split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
+      const kv = part.match(/^(forks|calls|depth)\s*=\s*(\d+)$/i);
+      if (kv) {
+        const num = Number(kv[2]);
+        if (Number.isFinite(num) && num >= 1) {
+          out[kv[1].toLowerCase()] = Math.floor(num);
+        }
+      }
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+// src/algebra/hash-source.ts
+var lastHashSource;
+var lastHashOut;
+function hashSource(s) {
+  if (s === lastHashSource && lastHashOut !== void 0) return lastHashOut;
+  let h1 = 2166136261;
+  let h2 = 2654435769;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    h1 ^= c;
+    h1 = Math.imul(h1, 16777619);
+    h2 = Math.imul(h2 ^ c, 16777619);
+  }
+  lastHashSource = s;
+  lastHashOut = `${(h1 >>> 0).toString(36)}-${(h2 >>> 0).toString(36)}_${s.length.toString(36)}`;
+  return lastHashOut;
+}
+function resetHashSourceCache() {
+  lastHashSource = void 0;
+  lastHashOut = void 0;
+}
+
+// src/algebra/sidecar-path.ts
+function normPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function stablePathKey(p) {
+  let fp = p;
+  if (fp.startsWith("file://")) {
+    fp = fp.slice("file://".length);
+    try {
+      fp = decodeURIComponent(fp);
+    } catch {
+    }
+  }
+  fp = normPath(fp);
+  const drive = /^\/([A-Za-z]:)(.*)$/.exec(fp);
+  if (drive) fp = `${drive[1]}${drive[2]}`;
+  if (/^[A-Za-z]:\//.test(fp)) return fp[0].toLowerCase() + fp.slice(1);
+  return fp;
+}
+function stablePathKeyGraph(m) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, vs] of m) {
+    const key = stablePathKey(k);
+    let set = out.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      out.set(key, set);
+    }
+    for (const v2 of vs) set.add(stablePathKey(v2));
+  }
+  return out;
+}
+function resolveDepPath(fromFile, spec) {
+  const s = normPath(spec);
+  if (!s.startsWith(".")) return s;
+  const from = normPath(fromFile);
+  const i = from.lastIndexOf("/");
+  const base = i >= 0 ? from.slice(0, i) : "";
+  const parts = base ? base.split("/") : [];
+  for (const seg of s.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") parts.pop();
+    else parts.push(seg);
+  }
+  return parts.join("/");
+}
+function isNodeModulesPath(p) {
+  const f = normPath(p);
+  if (f === "node_modules" || f.startsWith("node_modules/")) return true;
+  return f.includes("/node_modules/") || f.endsWith("/node_modules");
+}
+function sidecarPathOf(file) {
+  const f = normPath(file);
+  if (f.endsWith(".mjs")) return f.slice(0, -4) + ".nudo.js";
+  if (f.endsWith(".js")) return f.slice(0, -3) + ".nudo.js";
+  if (f.endsWith(".mts")) return f.slice(0, -4) + ".nudo.ts";
+  if (f.endsWith(".ts")) return f.slice(0, -3) + ".nudo.ts";
+  return `${f}.nudo.js`;
+}
 
 // src/algebra/constraint.ts
 var SELF = "__nudo_self__";
@@ -190,6 +883,28 @@ function union(...cs) {
     members: cs.map((c) => asNestedConstraint(c, "union member"))
   });
 }
+function nullable(c) {
+  return makeBuilder(void 0, [], {
+    members: [
+      asNestedConstraint(c, "nullable()"),
+      toPlainConstraint(litC(null)),
+      toPlainConstraint(litC(void 0))
+    ]
+  });
+}
+function constraintAdmitsNullish(c) {
+  if (c.members) return c.members.some((m) => constraintAdmitsNullish(m));
+  if (!c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.fn) return true;
+  for (const p of c.preds) {
+    for (const flat of p.op === "and" ? p.args : [p]) {
+      if (flat.op !== "eq") continue;
+      for (const side of [flat.a, flat.b]) {
+        if (side.op === "lit" && (side.value === null || side.value === void 0)) return true;
+      }
+    }
+  }
+  return false;
+}
 function fn(params, returns, opts) {
   const normalized = {};
   for (const [k, v2] of Object.entries(params)) {
@@ -261,6 +976,28 @@ function omit(c, keys) {
   }
   return makeBuilder(c.prim, c.preds, { fields });
 }
+var CONSTRAINT_BUILDERS = {
+  number,
+  string,
+  boolean,
+  any,
+  array,
+  shape,
+  lit: litC,
+  union,
+  nullable,
+  fn,
+  and: andC,
+  partial,
+  pick,
+  omit
+};
+var CONSTRAINT_BUILDER_NAMES = Object.keys(
+  CONSTRAINT_BUILDERS
+);
+var CONSTRAINT_EXPR_RE = new RegExp(
+  `^(${CONSTRAINT_BUILDER_NAMES.join("|")})\\s*\\(`
+);
 function substTerm(t, paramName) {
   if (t.op === "var" && t.id === SELF) return v(paramName);
   if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
@@ -388,21 +1125,26 @@ function memberLitValue(m) {
     leaves.push(p2);
   };
   m.preds.forEach(visit2);
-  if (leaves.length !== 1) return void 0;
+  if (leaves.length !== 1) return { ok: false };
   const p = leaves[0];
-  if (p.op !== "eq") return void 0;
-  if (p.a.op === "var" && p.b.op === "lit") return p.b.value;
-  if (p.b.op === "var" && p.a.op === "lit") return p.a.value;
-  return void 0;
+  if (p.op !== "eq") return { ok: false };
+  if (p.a.op === "var" && p.b.op === "lit") {
+    return { ok: true, v: p.b.value };
+  }
+  if (p.b.op === "var" && p.a.op === "lit") {
+    return { ok: true, v: p.a.value };
+  }
+  return { ok: false };
 }
 function samePrimLiteralUnionAbs(members, t) {
   if (members.length === 0) return void 0;
   const values = [];
   let prim;
   for (const m of members) {
-    const v2 = memberLitValue(m);
-    if (v2 === void 0) return void 0;
-    if (v2 === null) return void 0;
+    const mk = memberLitValue(m);
+    if (!mk.ok) return void 0;
+    const v2 = mk.v;
+    if (v2 === void 0 || v2 === null) return void 0;
     const mp = m.prim ?? (typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : "boolean");
     if (prim === void 0) prim = mp;
     else if (prim !== mp) return void 0;
@@ -461,10 +1203,10 @@ function constraintOnTermAbs(c, t) {
   if (c.prim) {
     return abs({ k: "prim", type: c.prim }, t, predOut, "path");
   }
-  const allEqNull = c.preds.length > 0 && c.preds.every(
-    (p) => p.op === "eq" && (p.b.op === "lit" && p.b.value === null || p.a.op === "lit" && p.a.value === null)
+  const allEqNullish = c.preds.length > 0 && c.preds.every(
+    (p) => p.op === "eq" && (p.b.op === "lit" && (p.b.value === null || p.b.value === void 0) || p.a.op === "lit" && (p.a.value === null || p.a.value === void 0))
   );
-  if (allEqNull) {
+  if (allEqNullish) {
     return abs({ k: "unknown" }, t, predOut, "path");
   }
   if (c.preds.length > 0) {
@@ -505,72 +1247,24 @@ function throwConstraintToKinds(c) {
   return void 0;
 }
 
-// src/algebra/hash-source.ts
-var lastHashSource;
-var lastHashOut;
-function hashSource(s) {
-  if (s === lastHashSource && lastHashOut !== void 0) return lastHashOut;
-  let h1 = 2166136261;
-  let h2 = 2654435769;
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    h1 ^= c;
-    h1 = Math.imul(h1, 16777619);
-    h2 = Math.imul(h2 ^ c, 16777619);
-  }
-  lastHashSource = s;
-  lastHashOut = `${(h1 >>> 0).toString(36)}-${(h2 >>> 0).toString(36)}_${s.length.toString(36)}`;
-  return lastHashOut;
-}
-function resetHashSourceCache() {
-  lastHashSource = void 0;
-  lastHashOut = void 0;
-}
-
-// src/algebra/sidecar-path.ts
-function normPath(p) {
-  return p.replace(/\\/g, "/");
-}
-function resolveDepPath(fromFile, spec) {
-  const s = normPath(spec);
-  if (!s.startsWith(".")) return s;
-  const from = normPath(fromFile);
-  const i = from.lastIndexOf("/");
-  const base = i >= 0 ? from.slice(0, i) : "";
-  const parts = base ? base.split("/") : [];
-  for (const seg of s.split("/")) {
-    if (seg === "" || seg === ".") continue;
-    if (seg === "..") parts.pop();
-    else parts.push(seg);
-  }
-  return parts.join("/");
-}
-function isNodeModulesPath(p) {
-  const f = normPath(p);
-  if (f === "node_modules" || f.startsWith("node_modules/")) return true;
-  return f.includes("/node_modules/") || f.endsWith("/node_modules");
-}
-function sidecarPathOf(file) {
-  const f = normPath(file);
-  if (f.endsWith(".mjs")) return f.slice(0, -4) + ".nudo.js";
-  if (f.endsWith(".js")) return f.slice(0, -3) + ".nudo.js";
-  if (f.endsWith(".mts")) return f.slice(0, -4) + ".nudo.ts";
-  if (f.endsWith(".ts")) return f.slice(0, -3) + ".nudo.ts";
-  return `${f}.nudo.js`;
-}
-
 // src/algebra/refine.ts
 function extractNudoImports(source) {
   const out = [];
-  const named = /@nudo:import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
-  let m;
-  while (m = named.exec(source)) {
-    const names = m[1].split(",").map((s) => s.trim()).filter(Boolean).map((s) => s.split(/\s+as\s+/).pop().trim());
-    out.push({ names, spec: m[2] });
+  for (const rec of extractNudoImportRecords(source)) {
+    out.push({ names: rec.names, spec: rec.spec });
   }
-  const ns = /@nudo:import\s+\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']/g;
-  while (m = ns.exec(source)) {
-    out.push({ names: [`*${m[1]}`], spec: m[2] });
+  for (const bad of scanMalformedNudoImports(source)) {
+    if (bad === "malformed-default") {
+      collectDiag({
+        code: "nudo:contract-syntax",
+        message: `Default @nudo:import is not supported (use named { a, b } or namespace * as ns)`
+      });
+    } else {
+      collectDiag({
+        code: "nudo:contract-syntax",
+        message: `Unrecognized @nudo:import form (expected { names } from "path" or * as ns from "path")`
+      });
+    }
   }
   return out;
 }
@@ -612,20 +1306,7 @@ var NudoSidecarError = class extends Error {
     this.code = code;
   }
 };
-var sidecarInjects = {
-  number,
-  string,
-  boolean,
-  shape,
-  array,
-  lit: litC,
-  union,
-  fn,
-  and: andC,
-  partial,
-  pick,
-  omit
-};
+var sidecarInjects = CONSTRAINT_BUILDERS;
 function isSidecarSpec(spec) {
   return spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts");
 }
@@ -974,6 +1655,7 @@ function execNudoModule(src, opts) {
   return execNudoModuleCached(src, opts ?? {});
 }
 var nudoModuleExecCache = /* @__PURE__ */ new Map();
+var nudoModuleFailCache = /* @__PURE__ */ new Map();
 var MAX_NUDO_MODULE_EXEC = 64;
 var MAX_SIDECAR_CLOSURE = 64;
 function sidecarDepClosure(src, fromFile, loadModule, out) {
@@ -991,7 +1673,12 @@ function sidecarDepClosure(src, fromFile, loadModule, out) {
     if (!isSidecarSpec(spec)) continue;
     const canonical = resolveDepPath(fromFile, spec);
     if (out.has(canonical)) continue;
-    const depSrc = loadModule(spec, fromFile);
+    let depSrc;
+    try {
+      depSrc = loadModule(spec, fromFile);
+    } catch {
+      depSrc = void 0;
+    }
     out.set(canonical, depSrc);
     if (depSrc === void 0) continue;
     const r = sidecarDepClosure(depSrc, canonical, loadModule, out);
@@ -1020,19 +1707,34 @@ function execNudoModuleCached(src, opts) {
       nudoModuleExecCache.set(key, hit);
       return hit;
     }
+    if (nudoModuleFailCache.has(key)) {
+      throw nudoModuleFailCache.get(key);
+    }
   }
-  const out = execSidecar(src, opts, opts.fromFile ? [opts.fromFile] : [], preloaded);
-  if (key !== void 0) {
-    if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
-      const oldest = nudoModuleExecCache.keys().next().value;
-      if (oldest !== void 0) nudoModuleExecCache.delete(oldest);
+  try {
+    const out = execSidecar(src, opts, opts.fromFile ? [opts.fromFile] : [], preloaded);
+    if (key !== void 0) {
+      if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
+        const oldest = nudoModuleExecCache.keys().next().value;
+        if (oldest !== void 0) nudoModuleExecCache.delete(oldest);
+      }
+      nudoModuleExecCache.set(key, out);
     }
-    nudoModuleExecCache.set(key, out);
+    return out;
+  } catch (e) {
+    if (key !== void 0) {
+      if (nudoModuleFailCache.size >= MAX_NUDO_MODULE_EXEC) {
+        const oldest = nudoModuleFailCache.keys().next().value;
+        if (oldest !== void 0) nudoModuleFailCache.delete(oldest);
+      }
+      nudoModuleFailCache.set(key, e);
+    }
+    throw e;
   }
-  return out;
 }
 function resetNudoModuleExecCache() {
   nudoModuleExecCache.clear();
+  nudoModuleFailCache.clear();
 }
 function collectConstraints(source, opts) {
   const map = /* @__PURE__ */ new Map();
@@ -1046,7 +1748,17 @@ function collectConstraints(source, opts) {
       });
       continue;
     }
-    const src = opts.loadModule(imp.spec, opts.fromFile);
+    let src;
+    try {
+      src = opts.loadModule(imp.spec, opts.fromFile);
+    } catch (e) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar '${imp.spec}' failed to load from '${opts.fromFile}': ${e instanceof Error ? e.message : String(e)}`,
+        file: opts.fromFile
+      });
+      continue;
+    }
     if (src === void 0) {
       collectDiag({
         code: "nudo:interface-load",
@@ -1102,36 +1814,25 @@ function collectConstraints(source, opts) {
   return map;
 }
 function extractRefineLines(source, fnName) {
-  const escaped = fnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const fnRe = new RegExp(
-    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}\\b|const\\s+${escaped}\\s*=)`
-  );
-  const m = source.match(fnRe);
-  if (!m || m.index === void 0) return [];
-  const before = source.slice(0, m.index);
-  const lines = before.split("\n");
-  const reqs = [];
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (line === "" || line === "*/") continue;
-    if (line.startsWith("*") || line.startsWith("/*") || line.startsWith("//")) {
-      const rm = line.match(/@nudo:contract\s+(.+)$/);
-      if (rm) reqs.unshift(rm[1].trim().replace(/\*\/$/, "").trim());
-      continue;
-    }
-    break;
-  }
-  return reqs;
+  const lines = fnDirectiveCommentLines(source, fnName);
+  return scanContractSegments(lines);
 }
 function extractRefinesFromSource(source, fnName, opts = {}) {
-  if (!source.includes("@nudo:contract")) return [];
+  if (!stripStringsKeepComments(source).includes("@nudo:contract")) return [];
   const constraints = collectConstraints(source, opts);
   const out = [];
   for (const line of extractRefineLines(source, fnName)) {
     const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
     for (const part of parts) {
       const m = part.match(/^(\w+)\s+([\w.]+)$/);
-      if (!m) continue;
+      if (!m) {
+        if (/^return\b/.test(part)) continue;
+        collectDiag({
+          code: "nudo:contract-syntax",
+          message: `Malformed @nudo:contract segment '${part}' (expected <param> <constraintName> or return <constraintName>; e.g. @nudo:contract x positive)`
+        });
+        continue;
+      }
       const [, param, cName] = m;
       if (param === "return") continue;
       const c = constraints.get(cName);
@@ -1155,13 +1856,21 @@ function refineToIndexedFull(source, fnName, paramNames, opts = {}) {
   return out;
 }
 function extractRefineReturnFromSource(source, fnName, opts = {}) {
-  if (!source.includes("@nudo:contract")) return void 0;
+  if (!stripStringsKeepComments(source).includes("@nudo:contract")) return void 0;
   const constraints = collectConstraints(source, opts);
   for (const line of extractRefineLines(source, fnName)) {
     const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
     for (const part of parts) {
       const m = part.match(/^return\s+([\w.]+)$/);
-      if (!m) continue;
+      if (!m) {
+        if (/^return\b/.test(part) && !/^return\s+[\w.]+$/.test(part)) {
+          collectDiag({
+            code: "nudo:contract-syntax",
+            message: `Malformed @nudo:contract return segment '${part}' (expected return <constraintName>)`
+          });
+        }
+        continue;
+      }
       const cName = m[1];
       const c = constraints.get(cName);
       if (!c) continue;
@@ -1171,59 +1880,21 @@ function extractRefineReturnFromSource(source, fnName, opts = {}) {
   return void 0;
 }
 function extractDeclaredThrows(source, fnName) {
-  if (!source.includes("@nudo:throws") && !source.includes("!! throws")) {
+  const directiveSrc = stripStringsKeepComments(source);
+  if (!directiveSrc.includes("@nudo:throws") && !directiveSrc.includes("!! throws")) {
     return void 0;
   }
-  const kinds = /* @__PURE__ */ new Set();
-  let any2 = false;
-  const escaped = fnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const fnRe = new RegExp(
-    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}\\b|const\\s+${escaped}\\s*=)`
-  );
-  const m = source.match(fnRe);
-  if (!m || m.index === void 0) return void 0;
-  const before = source.slice(0, m.index);
-  const lines = before.split("\n");
-  let seenComment = false;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (line === "") {
-      if (seenComment) break;
-      continue;
-    }
-    if (line === "*/") continue;
-    if (line.startsWith("*") || line.startsWith("/*") || line.startsWith("//")) {
-      seenComment = true;
-      const body = line.replace(/^[*/\s]+/, "").replace(/\*\/$/, "").trim();
-      const th = body.match(/@nudo:throws\s+(.+)$/i);
-      if (th) {
-        const spec = th[1].trim();
-        if (spec === "*") any2 = true;
-        else {
-          for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
-            if (k === "*") any2 = true;
-            else kinds.add(k);
-          }
-        }
-      }
-      const cs = body.match(/!!\s*throws(?:\s+([A-Za-z*][\w*|,\s]*))?/i);
-      if (cs) {
-        const spec = (cs[1] ?? "*").trim();
-        if (spec === "" || spec === "*") any2 = true;
-        else {
-          for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
-            if (k === "*") any2 = true;
-            else kinds.add(k);
-          }
-        }
-      }
-      continue;
-    }
-    break;
-  }
-  if (any2) return "*";
-  if (kinds.size > 0) return [...kinds];
-  return void 0;
+  const lines = fnDirectiveCommentLines(source, fnName);
+  const spec = scanThrowsDecl(lines);
+  if (spec === void 0) return void 0;
+  if (spec === "*") return "*";
+  return spec.split(",").filter(Boolean);
+}
+function extractFnBudget(source, fnName) {
+  const directiveSrc = stripStringsKeepComments(source);
+  if (!directiveSrc.includes("@nudo:budget")) return void 0;
+  const lines = fnDirectiveCommentLines(source, fnName);
+  return scanBudgetDecl(lines);
 }
 
 // src/algebra/interface.ts
@@ -1321,11 +1992,24 @@ function localNamedExports(source) {
   for (const stmt of ast.program.body) {
     const s = stmt;
     if (s.type === "ExportNamedDeclaration") {
-      if (s.source) continue;
+      if (s.source) {
+        const specs = s.specifiers ?? [];
+        for (const spec of specs) {
+          if (spec.type !== "ExportNamespaceSpecifier") continue;
+          const name = identName(spec.exported);
+          if (name) out.add(name);
+        }
+        continue;
+      }
       const d = s.declaration;
       if (!d) {
         const specs = s.specifiers ?? [];
         for (const spec of specs) {
+          if (spec.type === "ExportNamespaceSpecifier") {
+            const name2 = identName(spec.exported);
+            if (name2) out.add(name2);
+            continue;
+          }
           if (spec.type !== "ExportSpecifier") continue;
           const name = identName(spec.exported);
           if (!name) continue;
@@ -1473,17 +2157,53 @@ function sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir) {
   return false;
 }
 function isDefaultExportLocal(source, localName) {
+  const name = identBoundaryRegex(localName);
   const reList = new RegExp(
-    `export\\s*\\{[^}]*\\b${localName}\\s+as\\s+default\\b[^}]*\\}`,
+    `export\\s*\\{[^}]*${name}\\s+as\\s+default(?![\\w$])[^}]*\\}`,
     "m"
   );
   const reDefaultFn = new RegExp(
-    `export\\s+default\\s+(?:async\\s+)?function\\s+${localName}\\b`,
+    `export\\s+default\\s+(?:async\\s+)?function\\s+${name}`,
+    "m"
+  );
+  const reDefaultId = new RegExp(
+    `export\\s+default\\s+${name}`,
     "m"
   );
-  const reDefaultId = new RegExp(`export\\s+default\\s+${localName}\\b`, "m");
   return reList.test(source) || reDefaultFn.test(source) || reDefaultId.test(source);
 }
+function sidecarExportNames(sidecarSrc) {
+  try {
+    return localNamedExports(sidecarSrc);
+  } catch {
+    return void 0;
+  }
+}
+function sidecarMayBind(sidecarNames, fnName, source) {
+  if (!sidecarNames) return true;
+  if (sidecarNames.size === 0) return true;
+  if (sidecarNames.has(fnName)) return true;
+  if (sidecarNames.has("default") && isDefaultExportLocal(source, fnName)) return true;
+  if (fnName.includes(".")) {
+    const [cls, method] = fnName.split(".", 2);
+    if (cls && method) {
+      if (sidecarNames.has(`${cls}_${method}`)) return true;
+      if (sidecarNames.has(cls)) return true;
+      if (sidecarNames.has(method)) return true;
+    }
+  }
+  return false;
+}
+var sidecarLoadFailures = /* @__PURE__ */ new Map();
+function noteSidecarLoadFailure(sidecarPath, reason) {
+  const key = `${sidecarPath}\0${reason}`;
+  if (sidecarLoadFailures.has(key)) return false;
+  sidecarLoadFailures.set(key, reason);
+  return true;
+}
+function resetSidecarLoadFailureCache() {
+  sidecarLoadFailures.clear();
+}
 function loadSidecarBinding(source, fnName, opts) {
   const { loadModule, fromFile, autoBind, projectDir } = opts;
   if (!loadModule || !fromFile) return { ok: false };
@@ -1491,18 +2211,46 @@ function loadSidecarBinding(source, fnName, opts) {
   if (!sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir)) return { ok: false };
   if (!localNamedExports(source).has(fnName)) return { ok: false };
   const spec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
-  const sidecarSrc = loadModule(spec, fromFile);
+  let sidecarSrc;
+  try {
+    sidecarSrc = loadModule(spec, fromFile);
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    if (noteSidecarLoadFailure(sidecarPath, reason)) {
+      collectDiag2({
+        code: "nudo:interface-load",
+        message: `sidecar '${spec}' failed to load: ${reason}`,
+        file: sidecarPath
+      });
+    }
+    return { ok: false };
+  }
   if (sidecarSrc === void 0) return { ok: false };
   if (sidecarSrc === source) return { ok: false };
+  const scNames = sidecarExportNames(sidecarSrc);
+  if (!sidecarMayBind(scNames, fnName, source)) return { ok: false };
   let exports;
   try {
     exports = execNudoModule(sidecarSrc, { loadModule, fromFile: sidecarPath });
   } catch (e) {
-    collectDiag2({
-      code: e instanceof NudoSidecarError ? e.code : "nudo:interface-load",
-      message: `sidecar '${spec}' for '${fnName}' failed: ${e instanceof Error ? e.message : String(e)}`,
-      file: sidecarPath
-    });
+    const reason = e instanceof Error ? e.message : String(e);
+    const code = e instanceof NudoSidecarError ? e.code : "nudo:interface-load";
+    if (noteSidecarLoadFailure(sidecarPath, reason)) {
+      let affected = 1;
+      if (scNames && scNames.size > 0) {
+        const srcExports = localNamedExports(source);
+        let n = 0;
+        for (const name of srcExports) {
+          if (sidecarMayBind(scNames, name, source)) n++;
+        }
+        if (n > 0) affected = n;
+      }
+      collectDiag2({
+        code,
+        message: affected > 1 ? `sidecar '${spec}' failed to load: ${reason} (affects ${affected} bindings)` : `sidecar '${spec}' failed to load: ${reason}`,
+        file: sidecarPath
+      });
+    }
     return { ok: false };
   }
   let binding = exports[fnName];
@@ -1585,14 +2333,17 @@ function eqLitsOf(c) {
     if (p.op !== "eq") return;
     let term;
     let value;
+    let hasLit = false;
     if (p.a.op === "var" && p.b.op === "lit") {
       term = p.a;
       value = p.b.value;
+      hasLit = true;
     } else if (p.b.op === "var" && p.a.op === "lit") {
       term = p.b;
       value = p.a.value;
+      hasLit = true;
     }
-    if (term !== void 0 && value !== void 0) {
+    if (term !== void 0 && hasLit) {
       out.push({ term: termToString(term), value });
     }
   };
@@ -1758,7 +2509,12 @@ function sidecarClosureFingerprint(fromFile, opts) {
   const sidecarPath = sidecarPathOf(fromFile);
   if (!sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir)) return void 0;
   const spec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
-  const sidecarSrc = loadModule(spec, fromFile);
+  let sidecarSrc;
+  try {
+    sidecarSrc = loadModule(spec, fromFile);
+  } catch {
+    return void 0;
+  }
   if (sidecarSrc === void 0) return void 0;
   const parts = [];
   const seen = /* @__PURE__ */ new Set([sidecarPath]);
@@ -1772,7 +2528,12 @@ function sidecarClosureFingerprint(fromFile, opts) {
     }
     const { spec: s, from } = queue.shift();
     const depPath = resolveDepPath(from, s);
-    const depSrc = loadModule(s, from);
+    let depSrc;
+    try {
+      depSrc = loadModule(s, from);
+    } catch {
+      depSrc = void 0;
+    }
     parts.push(`${depPath}=${depSrc === void 0 ? "miss" : hashSource(depSrc)}`);
     if (depSrc !== void 0) enqueueSidecarDeps(depSrc, depPath, seen, queue);
   }
@@ -2055,7 +2816,7 @@ function hasModuleSyntax(file) {
   return false;
 }
 function canSkipLiteralCallScan(source, file) {
-  if (source.includes("@nudo:contract")) return false;
+  if (stripStringsKeepComments(source).includes("@nudo:contract")) return false;
   if (hasModuleSyntax(file)) return false;
   if (hasAnyCallLike(file)) return false;
   const fps = fnFingerprints(source, file);
@@ -2071,17 +2832,12 @@ function extractAllLoadSpecs(source) {
   const specs = /* @__PURE__ */ new Set();
   for (const imp of extractNudoImports(source)) specs.add(imp.spec);
   const isPathLikeSpec = (spec) => spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || /\.(ts|js|mjs|cjs|tsx|jsx)$/.test(spec);
-  const envRe = /@nudo:env\s+([^\n*]+)/g;
-  let envM;
-  while (envM = envRe.exec(source)) {
-    for (const part of envM[1].split(",")) {
-      const spec = part.trim().replace(/^['"]|['"]$/g, "");
-      if (spec && isPathLikeSpec(spec)) specs.add(spec);
-    }
+  for (const name of extractFileEnvNames(source)) {
+    if (isPathLikeSpec(name)) specs.add(name);
+  }
+  for (const rec of extractMockModuleRecords(source)) {
+    if (rec.fromPath) specs.add(rec.fromPath);
   }
-  const mockFromRe = /@nudo:mock-module\s+"[^"]+"\s+(?:\{[^}]*\}\s+)?from\s+["']([^"']+)["']/g;
-  let mockM;
-  while (mockM = mockFromRe.exec(source)) specs.add(mockM[1]);
   const patterns = [
     /\bfrom\s*['"]([^'"]+)['"]/g,
     /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
@@ -2098,6 +2854,13 @@ function sidecarSpecsOf(source) {
     (spec) => (spec.startsWith(".") || spec.startsWith("/")) && (spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts"))
   );
 }
+function loadOrMiss(loadModule, spec, from) {
+  try {
+    return loadModule(spec, from);
+  } catch {
+    return void 0;
+  }
+}
 function loadModuleDepsFingerprint(source, loadModule, fromFile) {
   const parts = [];
   const paths = [];
@@ -2116,7 +2879,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
     const sidecarPath = sidecarPathOf(entryFile);
     if (seen.has(sidecarPath)) return;
     const sidecarSpec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
-    const sidecarSrc = loadModule(sidecarSpec, entryFile);
+    const sidecarSrc = loadOrMiss(loadModule, sidecarSpec, entryFile);
     if (sidecarSrc === void 0) return;
     if (n >= MAX_LOAD_DEP_NODES) {
       truncated = true;
@@ -2140,7 +2903,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
       if (seen.has(path)) continue;
       seen.add(path);
       n++;
-      const src = loadModule(cur.spec, cur.from);
+      const src = loadOrMiss(loadModule, cur.spec, cur.from);
       parts.push(`sidecar:${path}=${src === void 0 ? "miss" : hashSource(src)}`);
       paths.push(path);
       contents.push({ path, content: src ?? null });
@@ -2161,7 +2924,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
     if (seen.has(path)) continue;
     seen.add(path);
     n++;
-    const src = loadModule(cur.spec, cur.from);
+    const src = loadOrMiss(loadModule, cur.spec, cur.from);
     parts.push(`${path}=${src === void 0 ? "miss" : hashSource(src)}`);
     paths.push(path);
     contents.push({ path, content: src ?? null });
@@ -2209,6 +2972,8 @@ function predKey(p, rename) {
       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) {
@@ -2359,6 +3124,8 @@ function renamePred(p, map) {
       return { op: "not", arg: renamePred(p.arg, map) };
     case "typeof":
       return { op: "typeof", t: renameTerm(p.t, map), type: p.type };
+    case "assumeFinite":
+      return { op: "assumeFinite", t: renameTerm(p.t, map) };
   }
 }
 function renameAbs(a, map) {
@@ -2767,7 +3534,7 @@ function unindexMemoKey(key) {
 function evictGeneralizeMemoForPaths(paths) {
   let n = 0;
   for (const raw of paths) {
-    const p = normPath(raw);
+    const p = stablePathKey(raw);
     const keys = memoDepIndex.get(p);
     if (!keys) continue;
     for (const key of [...keys]) {
@@ -2809,7 +3576,7 @@ function generalizeMemoKey(fnName, source, opts) {
   const budget = opts.budget ?? defaultLeakBudget;
   const deps = opts.depsFp ?? (r ? refineDepsFingerprint(source, r) : { fp: "-", paths: [], contents: [], truncated: false });
   const sc = opts.sidecarFp ?? (r?.loadModule && r.fromFile ? sidecarClosureFingerprint(r.fromFile, r) : void 0);
-  const scPath = sc !== void 0 && !sc.startsWith("trunc:") && r?.fromFile ? normPath(sidecarPathOf(r.fromFile)) : void 0;
+  const scPath = sc !== void 0 && !sc.startsWith("trunc:") && r?.fromFile ? sidecarPathOf(r.fromFile) : void 0;
   const srcPart = generalizeSourceKeyPart(source, fnName, opts.file);
   const key = [
     srcPart,
@@ -2845,8 +3612,9 @@ function generalizeMemoSet(key, value, depPaths) {
   }
   generalizeMemo.set(key, value);
   if (depPaths.length > 0) {
-    memoKeyDeps.set(key, depPaths);
-    for (const p of depPaths) {
+    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();
@@ -2993,6 +3761,40 @@ function extractFn(source, fnName, fileAst) {
       registerFnNode(propName, right);
     }
   }
+  for (const stmt of file.program.body) {
+    if (stmt.type !== "ExportNamedDeclaration" || stmt.declaration) continue;
+    if (stmt.source) continue;
+    const specs = stmt.specifiers ?? [];
+    for (const spec of specs) {
+      if (spec.type !== "ExportSpecifier") continue;
+      const localName = spec.local?.name;
+      const exportedName = spec.exported?.name ?? spec.exported?.value;
+      if (!localName || exportedName == null) continue;
+      const exp = String(exportedName);
+      if (exp === localName || env.fns.has(exp)) continue;
+      const target = env.fns.get(localName);
+      if (!target) continue;
+      env.fns.set(exp, target);
+      formalsByName.set(exp, formalsByName.get(localName) ?? []);
+    }
+  }
+  for (const scope of listFnDirectiveScopes(file)) {
+    if (env.fns.has(scope.name)) continue;
+    if (scope.name === "<anonymous>") continue;
+    const n = scope.node;
+    const isFnLike = n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression" || n.type === "ClassMethod" || n.type === "ClassPrivateMethod" || n.type === "ObjectMethod";
+    if (!isFnLike || !n.body) continue;
+    if ((n.type === "ClassMethod" || n.type === "ClassPrivateMethod" || n.type === "ObjectMethod") && n.kind && n.kind !== "method") {
+      continue;
+    }
+    const formals = formalParamsFromNodes(n.params ?? []);
+    env.fns.set(scope.name, {
+      params: formalParamDisplayNames(formals),
+      body: n.body,
+      async: n.async === true
+    });
+    formalsByName.set(scope.name, formals);
+  }
   const fn2 = env.fns.get(fnName);
   if (!fn2) return void 0;
   return { params: fn2.params, body: fn2.body, env, formals: formalsByName.get(fnName) ?? [] };
@@ -3027,7 +3829,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
   if (opts.refine) {
     try {
       const r = opts.refine;
-      const hasDirective = source.includes("@nudo:contract") || source.includes("@nudo:contract");
+      const hasDirective = stripStringsKeepComments(source).includes("@nudo:contract");
       const sc = opts.sidecarFp ?? (r.loadModule && r.fromFile ? sidecarClosureFingerprint(r.fromFile, r) : void 0);
       const eff = hasDirective || sc !== void 0 ? effectiveInterface(source, fnName, r) : void 0;
       const reqs = eff?.params ?? [];
@@ -3036,6 +3838,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
           param: e.param,
           pred: instantiateConstraint(e.constraint, e.param)
         }));
+        const patternFields = /* @__PURE__ */ new Map();
         for (const e of reqs) {
           const idx = params.indexOf(e.param);
           if (idx >= 0) {
@@ -3048,7 +3851,54 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
               abs: snapshotAbs(entryAbs),
               source: "refine"
             });
+            continue;
+          }
+          const hit = formals.length > 0 ? locateContractParam(formals, e.param) : void 0;
+          if (hit && hit.field !== void 0) {
+            let bag = patternFields.get(hit.index);
+            if (!bag) {
+              bag = {};
+              patternFields.set(hit.index, bag);
+            }
+            const fieldAbs = constraintToEntryAbs(e.constraint, e.param);
+            bag[hit.field] = {
+              abs: fieldAbs,
+              ...e.constraint.isOptional ? { optional: true } : {}
+            };
+          } else if (hit) {
+            const entryAbs = constraintToEntryAbs(e.constraint, e.param);
+            typeParams[hit.index] = {
+              id: typeParams[hit.index].id,
+              value: entryAbs
+            };
+            refineEntryShapes.set(e.param, {
+              abs: snapshotAbs(entryAbs),
+              source: "refine"
+            });
+          }
+        }
+        for (const [pIdx, bag] of patternFields) {
+          const slots = {};
+          for (const [key, rec] of Object.entries(bag)) {
+            slots[key] = {
+              value: rec.abs,
+              ...rec.optional ? { optional: true } : {}
+            };
           }
+          const objAbs = abs(
+            { k: "obj", slots },
+            v(params[pIdx] ?? `_p${pIdx}`),
+            void 0,
+            "path"
+          );
+          typeParams[pIdx] = {
+            id: typeParams[pIdx].id,
+            value: objAbs
+          };
+          refineEntryShapes.set(params[pIdx] ?? `_p${pIdx}`, {
+            abs: snapshotAbs(objAbs),
+            source: "refine"
+          });
         }
       }
     } catch {
@@ -3080,17 +3930,49 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
   const hasMocks = inject && Object.keys(inject.mocks ?? {}).length > 0;
   const hasEnv = inject && Object.keys(inject.envGlobals ?? {}).length > 0;
   const hasReps = inject && Object.keys(inject.replacements ?? {}).length > 0;
-  const hasFnMockDirective = /@nudo:mock\s+\w+\s*(?:=|from\b)/.test(source);
-  const hasModMockDirective = /@nudo:mock-module\b/.test(source);
+  const directiveSrc = stripStringsKeepComments(source);
+  const hasFnMockDirective = /@nudo:mock\s+\w+\s*(?:=|from\b)/.test(directiveSrc);
+  const hasModMockDirective = /@nudo:mock-module\b/.test(directiveSrc);
   const hasModInject = inject && inject.modules && Object.keys(inject.modules).length > 0;
   const mockGated = hasFnMockDirective && !hasMocks || hasModMockDirective && !hasModInject;
-  const envGatedSource = /@nudo:env\b/.test(source) && !hasEnv;
+  const envGatedSource = /@nudo:env\b/.test(directiveSrc) && !hasEnv;
   const boundNames = formals.flatMap(
     (f) => f.kind === "pattern" ? f.bound : [f.name]
   );
   const envGated = envGatedSource && freeIdentifiers(body, boundNames).size > 0;
-  const replaceGated = /@nudo:replace\b/.test(source) && !hasReps;
+  const replaceGated = /@nudo:replace\b/.test(directiveSrc) && !hasReps;
   const evalEligible = !unresolvableImports && !mockGated && !envGated && !replaceGated;
+  const fnBudget = extractFnBudget(source, fnName);
+  const runCore = (args, phi) => {
+    if (!evalEligible) return void 0;
+    try {
+      const evalRun = evalRunOf(source, opts.modules, opts.inject);
+      if (!evalRun) {
+        return void 0;
+      } else if (fnName.includes(".")) {
+        const [clsName, methodName] = fnName.split(".", 2);
+        const clsAbs = evalRun[clsName ?? ""];
+        if (clsAbs && typeof clsAbs === "object" && "shape" in clsAbs) {
+          const nCtor = ctorParamCountOf(fileAst, clsName ?? "");
+          const inst = $new(clsAbs, Array.from({ length: nCtor }, () => abs({ k: "any" }, void 0, pTrue, "path")));
+          return withExecPhi(phi, () => $invoke(inst, methodName ?? "", args));
+        }
+        return void 0;
+      } else if (fnName in evalRun) {
+        const evalArgs = args.map((a, i) => {
+          const shape2 = promoteScan.promotedShapes.get(params[i]);
+          if (shape2 && (a.shape.k === "any" || a.shape.k === "unknown")) {
+            return { shape: shape2, term: a.term, pred: a.pred, conf: "path" };
+          }
+          return a;
+        });
+        return callTranspiledExportFull(evalRun, fnName, evalArgs, { phi }).result;
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  };
   const run = (args, phi = pTrue) => {
     const { key, varOrder } = instantiateMemoKey(args, phi);
     const hit = instMemo.get(key);
@@ -3098,30 +3980,14 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
       return alphaRenameResult(hit.result, hit.varOrder, varOrder);
     }
     let result;
-    if (evalEligible) {
-      try {
-        const evalRun = evalRunOf(source, opts.modules, opts.inject);
-        if (!evalRun) {
-        } else if (fnName.includes(".")) {
-          const [clsName, methodName] = fnName.split(".", 2);
-          const clsAbs = evalRun[clsName ?? ""];
-          if (clsAbs && typeof clsAbs === "object" && "shape" in clsAbs) {
-            const nCtor = ctorParamCountOf(fileAst, clsName ?? "");
-            const inst = $new(clsAbs, Array.from({ length: nCtor }, () => abs({ k: "any" }, void 0, pTrue, "path")));
-            result = withExecPhi(phi, () => $invoke(inst, methodName ?? "", args));
-          }
-        } else if (fnName in evalRun) {
-          const evalArgs = args.map((a, i) => {
-            const shape2 = promoteScan.promotedShapes.get(params[i]);
-            if (shape2 && (a.shape.k === "any" || a.shape.k === "unknown")) {
-              return { shape: shape2, term: a.term, pred: a.pred, conf: "path" };
-            }
-            return a;
-          });
-          result = callTranspiledExportFull(evalRun, fnName, evalArgs, { phi }).result;
-        }
-      } catch {
-      }
+    if (fnBudget) {
+      withFnBudgetOverride(fnBudget, () => {
+        withEvalBudgetOverride(fnBudget, () => {
+          result = runCore(args, phi);
+        });
+      });
+    } else {
+      result = runCore(args, phi);
     }
     if (result === void 0) {
       result = abs({ k: "unknown" }, void 0, void 0, "opaque");
@@ -3310,6 +4176,8 @@ function primMatches(prim, lv) {
       return typeof lv === "boolean";
     case "object":
       return lv === null;
+    case "undefined":
+      return lv === void 0;
     default:
       return false;
   }
@@ -3317,8 +4185,9 @@ function primMatches(prim, lv) {
 function predHolds(lv, p) {
   switch (p.op) {
     case "eq": {
-      const v2 = selfEqLiteral(p);
-      return v2 !== void 0 && lv === v2;
+      const litT = isSelfVar(p.a) && p.b.op === "lit" ? p.b : isSelfVar(p.b) && p.a.op === "lit" ? p.a : void 0;
+      if (!litT) return false;
+      return Object.is(lv, litT.value);
     }
     case "gt":
     case "ge":
@@ -3336,11 +4205,6 @@ function predHolds(lv, p) {
       return false;
   }
 }
-function selfEqLiteral(p) {
-  if (isSelfVar(p.a) && p.b.op === "lit") return p.b.value;
-  if (isSelfVar(p.b) && p.a.op === "lit") return p.a.value;
-  return void 0;
-}
 function cmpHolds(x, op, n) {
   switch (op) {
     case "gt":
@@ -3629,7 +4493,8 @@ function extractLiteralEvidence(rec, idx) {
   const absArg = rec.argAbs?.[idx];
   if (!absArg) return void 0;
   if (absArg.conf !== "exact" && absArg.conf !== "path") return void 0;
-  const lv = litValue(absArg);
+  const lvR = litValue(absArg);
+  const lv = lvR.ok ? lvR.value : void 0;
   if (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") {
     return lv;
   }
@@ -3689,6 +4554,7 @@ function resolveExportSource(modSrc, fnName, loadSpecFrom, depth = 0, baseFromFi
   }
   const file = parseSource(modSrc);
   let nextSpec;
+  let nextFnName = fnName;
   for (const stmt of file.program.body) {
     if (stmt.type !== "ExportNamedDeclaration" && stmt.type !== "ExportAllDeclaration") continue;
     const src = stmt.source;
@@ -3701,8 +4567,11 @@ function resolveExportSource(modSrc, fnName, loadSpecFrom, depth = 0, baseFromFi
     for (const sp of clause) {
       if (sp.type !== "ExportSpecifier") continue;
       const local = sp.local;
-      if (local?.type === "Identifier" && local.name === fnName) {
+      const exported = sp.exported ?? sp.local;
+      const exportedName = exported?.type === "Identifier" ? exported.name : exported && "value" in exported ? String(exported.value ?? "") : void 0;
+      if (exportedName === fnName) {
         nextSpec = String(src.value);
+        nextFnName = local?.type === "Identifier" && local.name ? local.name : fnName;
         break;
       }
     }
@@ -3715,7 +4584,7 @@ function resolveExportSource(modSrc, fnName, loadSpecFrom, depth = 0, baseFromFi
   const nextFromFile = hopFrom ? resolveDepPath(hopFrom, nextSpec) : "";
   return resolveExportSource(
     next,
-    fnName,
+    nextFnName,
     loadSpecFrom,
     depth + 1,
     baseFromFile,
@@ -4143,7 +5012,8 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         }
         arg = projected;
       }
-      const lv = litValue(arg);
+      const lvR = litValue(arg);
+      const lv = lvR.ok ? lvR.value : void 0;
       const isStr = arg.shape.k === "prim" && arg.shape.type === "string";
       const strLen = typeof lv === "string" ? lv.length : void 0;
       const argIsUndef = isExactUndef(arg);
@@ -4352,7 +5222,8 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
       }
     }
     if (isIntFlag(constraint)) {
-      const iv = litValue(fieldAbs);
+      const ivR = litValue(fieldAbs);
+      const iv = ivR.ok ? ivR.value : void 0;
       if (typeof iv === "number" && !Number.isInteger(iv)) {
         out.push({
           severity: "error",
@@ -4394,7 +5265,8 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         });
       }
     }
-    const lv = litValue(fieldAbs);
+    const lvR = litValue(fieldAbs);
+    const lv = lvR.ok ? lvR.value : void 0;
     const sv = typeof lv === "string" ? lv.length : void 0;
     const isStr = fieldAbs.shape.k === "prim" && fieldAbs.shape.type === "string";
     for (const p of constraint.preds) {
@@ -4447,7 +5319,9 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         }
       }
     }
-    if (lv !== void 0 && (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") && ((constraint.members?.length ?? 0) > 0 || constraint.preds.some((p) => p.op === "eq")) && !literalMeetsConstraint(lv, constraint)) {
+    const fieldLit = fieldAbs.term?.op === "lit" ? fieldAbs.term.value : void 0;
+    const fieldIsLit = fieldAbs.term?.op === "lit";
+    if (fieldIsLit && (typeof fieldLit === "number" || typeof fieldLit === "string" || typeof fieldLit === "boolean" || fieldLit === null || fieldLit === void 0) && ((constraint.members?.length ?? 0) > 0 || constraint.preds.some((p) => p.op === "eq")) && !literalMeetsConstraint(fieldLit, constraint)) {
       out.push({
         severity: "error",
         code: "nudo:constraint-violated",
@@ -4531,7 +5405,8 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         }
       }
       if (isIntFlag(c)) {
-        const iv = litValue(arg);
+        const ivR = litValue(arg);
+        const iv = ivR.ok ? ivR.value : void 0;
         if (typeof iv === "number" && !Number.isInteger(iv)) {
           out.push({
             severity: "error",
@@ -4845,6 +5720,29 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
 }
 
 export {
+  listFnDirectiveScopes,
+  findFnDirectiveScope,
+  fnDirectiveCommentLines,
+  parseEnvPayload,
+  parseMockModulePayload,
+  parseNudoImportPayload,
+  extractFileEnvNames,
+  extractMockModuleRecords,
+  extractNudoImportRecords,
+  extractBalancedParens,
+  scanCaseTags,
+  scanCaseArgSpans,
+  scanContractSegments,
+  scanThrowsDecl,
+  scanBudgetDecl,
+  hashSource,
+  resetHashSourceCache,
+  normPath,
+  stablePathKey,
+  stablePathKeyGraph,
+  resolveDepPath,
+  isNodeModulesPath,
+  sidecarPathOf,
   SELF,
   getTerm,
   lenTerm,
@@ -4858,21 +5756,21 @@ export {
   shape,
   litC,
   union,
+  nullable,
+  constraintAdmitsNullish,
   fn,
   andC,
   partial,
   pick,
   omit,
+  CONSTRAINT_BUILDERS,
+  CONSTRAINT_BUILDER_NAMES,
+  CONSTRAINT_EXPR_RE,
   instantiateConstraint,
+  instantiateOnTerm,
   constraintToEntryAbs,
   fnConstraintToEntryReqs,
   throwConstraintToKinds,
-  hashSource,
-  resetHashSourceCache,
-  normPath,
-  resolveDepPath,
-  isNodeModulesPath,
-  sidecarPathOf,
   extractNudoImports,
   setRefineDiagCollector,
   refineDiagCount,
@@ -4885,12 +5783,14 @@ export {
   refineToIndexedFull,
   extractRefineReturnFromSource,
   extractDeclaredThrows,
+  extractFnBudget,
   setInterfaceDiagCollector,
   interfaceDiagCount,
   takeInterfaceDiags,
   takeInterfaceDiagsSince,
   localNamedExports,
   generatedExportNames,
+  resetSidecarLoadFailureCache,
   effectiveInterface,
   sidecarClosureFingerprint,
   formatConstraint,