@nudojs/core 1.3.0 → 1.4.0

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

@@ -45,7 +45,614 @@ import {
   withEvalBudgetOverride,
   withExecPhi,
   withFnBudgetOverride
-} from "./chunk-CKH6GQAI.js";
+} 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;
@@ -73,6 +680,34 @@ function resetHashSourceCache() {
 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;
@@ -341,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) {
@@ -593,15 +1250,21 @@ function throwConstraintToKinds(c) {
 // 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;
 }
@@ -643,21 +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,
-  nullable
-};
+var sidecarInjects = CONSTRAINT_BUILDERS;
 function isSidecarSpec(spec) {
   return spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts");
 }
@@ -1024,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);
@@ -1094,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",
@@ -1150,26 +1814,8 @@ function collectConstraints(source, opts) {
   return map;
 }
 function extractRefineLines(source, fnName) {
-  const escaped = identBoundaryRegex(fnName);
-  const fnRe = new RegExp(
-    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}|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 (!stripStringsKeepComments(source).includes("@nudo:contract")) return [];
@@ -1179,7 +1825,14 @@ function extractRefinesFromSource(source, fnName, opts = {}) {
     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);
@@ -1209,7 +1862,15 @@ function extractRefineReturnFromSource(source, fnName, opts = {}) {
     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;
@@ -1223,98 +1884,17 @@ function extractDeclaredThrows(source, fnName) {
   if (!directiveSrc.includes("@nudo:throws") && !directiveSrc.includes("!! throws")) {
     return void 0;
   }
-  const kinds = /* @__PURE__ */ new Set();
-  let any2 = false;
-  const escaped = identBoundaryRegex(fnName);
-  const fnRe = new RegExp(
-    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}|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 escaped = identBoundaryRegex(fnName);
-  const fnRe = new RegExp(
-    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}|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;
-  const out = {};
-  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 bd = body.match(/@nudo:budget\s+(.+)$/i);
-      if (bd) {
-        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 n = Number(kv[2]);
-            if (Number.isFinite(n) && n >= 1) {
-              const key = kv[1].toLowerCase();
-              out[key] = Math.floor(n);
-            }
-          }
-        }
-      }
-      continue;
-    }
-    break;
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
+  const lines = fnDirectiveCommentLines(source, fnName);
+  return scanBudgetDecl(lines);
 }
 
 // src/algebra/interface.ts
@@ -1631,7 +2211,20 @@ 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);
@@ -1916,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]);
@@ -1930,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);
   }
@@ -2229,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,
@@ -2256,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 = [];
@@ -2274,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;
@@ -2298,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 });
@@ -2319,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 });
@@ -2929,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]) {
@@ -2971,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,
@@ -3007,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();
@@ -3172,6 +3778,23 @@ function extractFn(source, fnName, fileAst) {
       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) ?? [] };
@@ -3553,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;
   }
@@ -3560,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":
@@ -3579,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":
@@ -3872,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;
   }
@@ -4390,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);
@@ -4599,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",
@@ -4641,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) {
@@ -4694,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",
@@ -4778,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",
@@ -5092,9 +5720,26 @@ 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,
@@ -5118,6 +5763,9 @@ export {
   partial,
   pick,
   omit,
+  CONSTRAINT_BUILDERS,
+  CONSTRAINT_BUILDER_NAMES,
+  CONSTRAINT_EXPR_RE,
   instantiateConstraint,
   instantiateOnTerm,
   constraintToEntryAbs,