@nudojs/service 5.0.0-beta.0 → 5.0.0-beta.1

package/dist/{chunk-HEU4WON5.js → emit/index.js}

@@ -1,159 +1,25 @@
 import {
-  unifiedDiff
-} from "./chunk-YLVZMHWC.js";
+  DiskCache,
+  collectLoadDepContents,
+  ifaceCacheKey,
+  injectBindings,
+  typeExprToDirective
+} from "../chunk-J2PUE4NV.js";
 import {
   analyzeFileAsync,
   defaultLoadModule,
   evalAbsModuleGraph
-} from "./chunk-QAFMPM2E.js";
+} from "../chunk-NQXAF4LJ.js";
 import {
   diskCacheRoot,
   findProjectConfig,
   interfaceConfig,
   matchesEmitAllowlist
-} from "./chunk-YLALZXTZ.js";
-
-// src/dep-contents.ts
-import { loadModuleDepsFingerprint } from "@nudojs/core/internal";
-function collectLoadDepContents(filePath, source, loadModule) {
-  const fp = loadModuleDepsFingerprint(source, loadModule, filePath);
-  const depContents = fp.contents.length > 0 ? fp.contents : fp.paths.map((path) => ({ path, content: null }));
-  return { depContents, truncated: fp.truncated };
-}
-
-// src/disk-cache.ts
-import { createHash } from "crypto";
-import { createRequire } from "module";
-import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from "fs";
-import { join, dirname, relative, sep, isAbsolute } from "path";
-function readServiceVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    for (const p of ["../package.json", "./package.json", "../../package.json"]) {
-      try {
-        const pkg = require2(p);
-        if (pkg?.name === "@nudojs/service" && pkg.version) return pkg.version;
-        if (pkg?.version && p.includes("service")) return pkg.version;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return "0";
-}
-var ANALYSIS_ABI = `nudo-check-cache-v3+${readServiceVersion()}`;
-function sha256Hex(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-function relativizePath(p, root) {
-  const norm = p.split(sep).join("/");
-  if (!root) return norm;
-  const r = relative(root, p).split(sep).join("/");
-  if (!r.startsWith("..") && !isAbsolute(r)) return r;
-  return `ext:${createHash("sha256").update(norm).digest("hex").slice(0, 16)}`;
-}
-function sanitizeCacheNamespace(ns) {
-  return ns.replace(/[^a-z0-9_-]/gi, "_").replace(/^_+|_+$/g, "") || "cache";
-}
-var DiskCache = class {
-  root;
-  ns;
-  enabled = false;
-  constructor(opts) {
-    this.root = opts.root;
-    this.ns = sanitizeCacheNamespace(opts.namespace);
-    this.enabled = !!opts.root;
-  }
-  pathFor(key) {
-    if (!/^[a-f0-9]{16,128}$/i.test(key)) {
-      throw new Error("DiskCache key must be a hex digest");
-    }
-    return join(this.root, this.ns, key.slice(0, 2), `${key}.json`);
-  }
-  get(key) {
-    if (!this.enabled || !this.root) return void 0;
-    try {
-      const p = this.pathFor(key);
-      if (!existsSync(p)) return void 0;
-      const raw = readFileSync(p, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed?.abi !== ANALYSIS_ABI) return void 0;
-      return parsed.value;
-    } catch {
-      return void 0;
-    }
-  }
-  set(key, value) {
-    if (!this.enabled || !this.root) return;
-    try {
-      const p = this.pathFor(key);
-      mkdirSync(dirname(p), { recursive: true });
-      writeFileSync(p, JSON.stringify({ abi: ANALYSIS_ABI, value }), "utf8");
-    } catch {
-    }
-  }
-  clearNamespace() {
-    if (!this.enabled || !this.root) return;
-    try {
-      rmSync(join(this.root, this.ns), { recursive: true, force: true });
-    } catch {
-    }
-  }
-};
-function checkCacheKey(filePath, source, opts) {
-  const rel = relativizePath(filePath, opts.projectDir);
-  const sidecarSha = opts.sidecarContent != null ? sha256Hex(opts.sidecarContent) : "nosidecar";
-  const depSeg = (opts.depContents ?? []).map(
-    (d) => `${relativizePath(d.path, opts.projectDir)}\0${d.content != null ? sha256Hex(d.content) : "miss"}`
-  ).join("\n");
-  const envSeg = (opts.projectEnvNames ?? []).length > 0 ? [...opts.projectEnvNames ?? []].sort().join(",") : "-";
-  const cfgSeg = opts.analysisCfg ? `${opts.analysisCfg.mode ?? "-"}|${opts.analysisCfg.evalMissingSlot ?? "-"}|${opts.analysisCfg.callSiteBudget ?? "-"}|${opts.analysisCfg.entryThrows ?? "-"}|${opts.analysisCfg.ignoreThrows ?? "-"}` : "-";
-  return sha256Hex(
-    [
-      ANALYSIS_ABI,
-      rel,
-      opts.autoBind ? "ab1" : "ab0",
-      sha256Hex(source),
-      sidecarSha,
-      depSeg,
-      envSeg,
-      cfgSeg
-    ].join("\0")
-  );
-}
-function ifaceCacheKey(filePath, source, opts) {
-  const rel = relativizePath(filePath, opts.projectDir);
-  const sidecarSeg = opts.autoBind && opts.sidecarSource !== void 0 ? `sc:${sha256Hex(opts.sidecarSource)}` : "sc0";
-  const depSeg = (opts.depContents ?? []).map(
-    (d) => `${relativizePath(d.path, opts.projectDir)}\0${d.content != null ? sha256Hex(d.content) : "miss"}`
-  ).join("\n");
-  const envSeg = (opts.projectEnvNames ?? []).length > 0 ? [...opts.projectEnvNames ?? []].sort().join(",") : "-";
-  return sha256Hex(
-    [
-      ANALYSIS_ABI,
-      "iface",
-      rel,
-      opts.autoBind ? "ab1" : "ab0",
-      sha256Hex(source),
-      sidecarSeg,
-      depSeg,
-      envSeg
-    ].join("\0")
-  );
-}
-function extractNudoImportSpecs(source) {
-  const specs = /* @__PURE__ */ new Set();
-  const named = /@nudo:import\s*\{[^}]*\}\s*from\s*["']([^"']+)["']/g;
-  const ns = /@nudo:import\s+\*\s+as\s+\w+\s+from\s*["']([^"']+)["']/g;
-  let m;
-  while (m = named.exec(source)) specs.add(m[1]);
-  while (m = ns.exec(source)) specs.add(m[1]);
-  return [...specs];
-}
+} from "../chunk-ZXVAX7DE.js";
 
-// src/interface-surface.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, resolve } from "path";
+// src/emit/interface-surface.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, resolve } from "path";
 import {
   effectiveInterface,
   formatConstraint,
@@ -199,11 +65,11 @@ function cachedToEffective(e) {
 }
 async function interfaceSurface(filePath, opts = {}) {
   const abs = resolve(filePath);
-  const source = opts.source ?? readFileSync2(abs, "utf-8");
+  const source = opts.source ?? readFileSync(abs, "utf-8");
   const fromBuffer = opts.source !== void 0;
   const ifaceSince = interfaceDiagCount();
   const refineSince = refineDiagCount();
-  const proj = findProjectConfig(dirname2(abs));
+  const proj = findProjectConfig(dirname(abs));
   const autoBind = opts.autoBind ?? interfaceConfig(proj?.config).autoBind;
   const loadModule = opts.loadModule ?? defaultLoadModule;
   const exported = localNamedExports(source);
@@ -222,7 +88,7 @@ async function interfaceSurface(filePath, opts = {}) {
         if (autoBind !== false) {
           const openSc = loadModule(`./${sc.slice(sc.lastIndexOf("/") + 1)}`, abs);
           if (openSc !== void 0) sidecarSource = openSc;
-          else if (existsSync2(sc)) sidecarSource = readFileSync2(sc, "utf-8");
+          else if (existsSync(sc)) sidecarSource = readFileSync(sc, "utf-8");
         }
       } catch {
         sidecarSource = void 0;
@@ -314,9 +180,9 @@ async function interfaceSurface(filePath, opts = {}) {
   return entries;
 }
 
-// src/interface-emitter.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync, unlinkSync } from "fs";
-import { basename, dirname as dirname3, relative as relative2, resolve as resolve2 } from "path";
+// src/emit/interface-emitter.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, renameSync, unlinkSync } from "fs";
+import { basename, dirname as dirname2, relative, resolve as resolve2 } from "path";
 import {
   execNudoModule,
   formatConstraint as formatConstraint2,
@@ -332,6 +198,365 @@ import {
   takeRefineDiagsSince as takeRefineDiagsSince2
 } from "@nudojs/core";
 import { randomBytes } from "crypto";
+
+// src/emit/case-emitter.ts
+import { parse, extractDirectives } from "@nudojs/parser";
+var GENERATED_PREFIX = "call@";
+var GENERATED_CASE_LINE_REGEX = /^\s*\*?\s*@nudo:case\s+"(call@[^"]*)"/;
+var IDENT_KEY_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var NUMBER_LITERAL_REGEX = /^-?\d+(\.\d+)?$/;
+var UNSAFE_STRING_CHARS = /[,()[\]{}]/;
+var UNSAFE_KEY_CHARS = /[,()[\]{}:]/;
+var CONTROL_CHARS = /[\x00-\x1f\x7f]/;
+function serializeStringLiteral(value) {
+  if (CONTROL_CHARS.test(value)) return null;
+  if (value.includes("*/")) return null;
+  if (UNSAFE_STRING_CHARS.test(value)) return null;
+  const hasDbl = value.includes('"');
+  const hasSgl = value.includes("'");
+  if (hasDbl && hasSgl) return null;
+  return hasDbl ? `'${value}'` : `"${value}"`;
+}
+function serializeObjectKey(key) {
+  if (IDENT_KEY_REGEX.test(key)) return key;
+  if (CONTROL_CHARS.test(key)) return null;
+  if (key.includes('"')) return null;
+  if (UNSAFE_KEY_CHARS.test(key) || key.includes("*/")) return null;
+  if (/^['"]|['"]$/.test(key)) return null;
+  return `"${key}"`;
+}
+function serializeCaseArg(a) {
+  const s = a.shape;
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) return null;
+      const n = String(v);
+      return NUMBER_LITERAL_REGEX.test(n) ? n : null;
+    }
+    if (typeof v === "boolean") return v ? "true" : "false";
+    if (v === null) return "null";
+    if (v === void 0) return "undefined";
+    if (typeof v === "bigint") return null;
+    if (typeof v === "string") return serializeStringLiteral(v);
+    return null;
+  }
+  switch (s.k) {
+    case "prim":
+      if (s.type === "number") return "number()";
+      if (s.type === "string") return "string()";
+      if (s.type === "boolean") return "boolean()";
+      return null;
+    case "unknown":
+    case "any":
+      return "any()";
+    case "never":
+      return "never";
+    case "sum": {
+      const parts = [];
+      for (const member of s.members) {
+        const ser = serializeCaseArg(member);
+        if (ser === null) return null;
+        parts.push(ser);
+      }
+      return `union(${parts.join(", ")})`;
+    }
+    case "arr": {
+      const el = serializeCaseArg(s.element);
+      return el === null ? null : `array(${el})`;
+    }
+    case "tuple": {
+      const parts = [];
+      for (const el of s.elements) {
+        const ser = serializeCaseArg(el);
+        if (ser === null) return null;
+        parts.push(ser);
+      }
+      return `[${parts.join(", ")}]`;
+    }
+    case "obj": {
+      const parts = [];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const vs = serializeCaseArg(slot.value);
+        if (vs === null) return null;
+        const ks = serializeObjectKey(key);
+        if (ks === null) return null;
+        parts.push(`${ks}: ${vs}`);
+      }
+      return parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+    }
+    default:
+      return null;
+  }
+}
+function buildCaseDirective(name, argsAbs) {
+  if (name.includes('"') || /[\r\n]/.test(name)) return null;
+  const parts = [];
+  for (const arg of argsAbs) {
+    const s = serializeCaseArg(arg);
+    if (s === null) return null;
+    parts.push(s);
+  }
+  return ` * @nudo:case "${name}" (${parts.join(", ")})`;
+}
+function stripGeneratedCaseDirectives(source) {
+  const lines = source.split("\n");
+  const removed = [];
+  const drop = new Array(lines.length).fill(false);
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(GENERATED_CASE_LINE_REGEX);
+    if (m) {
+      drop[i] = true;
+      removed.push(m[1]);
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*\/\*\*\s*$/.test(lines[i])) continue;
+    let j = i + 1;
+    let clean = true;
+    while (j < lines.length) {
+      if (/\*\//.test(lines[j])) break;
+      if (/\/\*/.test(lines[j])) {
+        clean = false;
+        break;
+      }
+      j++;
+    }
+    if (!clean || j >= lines.length) continue;
+    if (!/^\s*\*\/\s*$/.test(lines[j])) continue;
+    let onlyFiller = true;
+    for (let k = i + 1; k < j; k++) {
+      if (drop[k]) continue;
+      const t = lines[k].trim();
+      if (t !== "" && !/^\*{1,2}$/.test(t)) {
+        onlyFiller = false;
+        break;
+      }
+    }
+    if (onlyFiller) {
+      for (let k = i; k <= j; k++) drop[k] = true;
+    }
+  }
+  return {
+    source: lines.filter((_, i) => !drop[i]).join("\n"),
+    removed
+  };
+}
+function collectExistingCases(source) {
+  const byName = /* @__PURE__ */ new Map();
+  let ast;
+  try {
+    ast = parse(source, { errorRecovery: true });
+  } catch {
+    return byName;
+  }
+  for (const { name, directives } of extractDirectives(ast)) {
+    for (const d of directives) {
+      if (d.kind !== "case") continue;
+      const list = byName.get(name);
+      if (list) list.push(d);
+      else byName.set(name, [d]);
+    }
+  }
+  return byName;
+}
+function insertGeneratedCaseDirectives(source, analysis) {
+  const written = [];
+  const skipped = [];
+  const existing = collectExistingCases(source);
+  const edits = [];
+  for (const fn of analysis.functions) {
+    const existingCases = existing.get(fn.name) ?? [];
+    if (existingCases.some((c) => !c.name.startsWith(GENERATED_PREFIX))) {
+      skipped.push({ fn: fn.name, reason: "hand-written" });
+      continue;
+    }
+    if (existingCases.length > 0) {
+      skipped.push({ fn: fn.name, reason: "already-generated" });
+      continue;
+    }
+    if (fn.skipped) {
+      skipped.push({ fn: fn.name, reason: "skipped" });
+      continue;
+    }
+    if (fn.noDeclaration) {
+      skipped.push({ fn: fn.name, reason: "no-declaration" });
+      continue;
+    }
+    if (fn.entryOnly) {
+      skipped.push({ fn: fn.name, reason: "entry-only" });
+      continue;
+    }
+    const callsiteCases = fn.cases.filter((c) => c.source === "callsite");
+    if (callsiteCases.length === 0) {
+      skipped.push({ fn: fn.name, reason: "no-serializable-cases", detail: "no callsite cases" });
+      continue;
+    }
+    const built = [];
+    const names = [];
+    for (const c of callsiteCases) {
+      const directive = buildCaseDirective(c.name, c.argAbs ?? []);
+      if (directive === null) {
+        skipped.push({ fn: fn.name, reason: "no-serializable-cases", detail: `case ${c.name} not serializable` });
+      } else {
+        built.push(directive);
+        names.push(c.name);
+      }
+    }
+    if (built.length === 0) continue;
+    edits.push({ line: fn.loc.start.line, column: fn.loc.start.column, directives: built, fn: fn.name });
+    written.push({ fn: fn.name, cases: names });
+  }
+  edits.sort((a, b) => b.line - a.line);
+  const lines = source.split("\n");
+  for (const edit of edits) {
+    const declIdx = edit.line - 1;
+    const indent = " ".repeat(edit.column);
+    let insertIdx = -1;
+    let blockIndent = "";
+    const aboveIdx = declIdx - 1;
+    if (aboveIdx >= 0 && /^\s*\*\/\s*$/.test(lines[aboveIdx])) {
+      let s = aboveIdx - 1;
+      while (s >= 0) {
+        const t = lines[s];
+        if (/^\s*\/\*\*/.test(t)) {
+          insertIdx = s + 1;
+          blockIndent = t.match(/^\s*/)?.[0] ?? "";
+          break;
+        }
+        if (/^\s*\*/.test(t) || t.trim() === "") {
+          s--;
+          continue;
+        }
+        break;
+      }
+    }
+    if (insertIdx >= 0) {
+      lines.splice(insertIdx, 0, ...edit.directives.map((d) => blockIndent + d));
+    } else {
+      lines.splice(declIdx, 0, `${indent}/**`, ...edit.directives.map((d) => indent + d), `${indent} */`);
+    }
+  }
+  return {
+    source: lines.join("\n"),
+    changed: written.length > 0,
+    written,
+    skipped
+  };
+}
+function diffOps(a, b) {
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const midA = a.slice(start, endA);
+  const midB = b.slice(start, endB);
+  const n = midA.length;
+  const m = midB.length;
+  const dp = new Int32Array((n + 1) * (m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2 * (m + 1) + j2] = midA[i2] === midB[j2] ? dp[(i2 + 1) * (m + 1) + (j2 + 1)] + 1 : Math.max(dp[(i2 + 1) * (m + 1) + j2], dp[i2 * (m + 1) + (j2 + 1)]);
+    }
+  }
+  const ops = [];
+  for (let k = 0; k < start; k++) ops.push({ type: "equal", text: a[k] });
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (midA[i] === midB[j]) {
+      ops.push({ type: "equal", text: midA[i] });
+      i++;
+      j++;
+    } else if (dp[(i + 1) * (m + 1) + j] >= dp[i * (m + 1) + (j + 1)]) {
+      ops.push({ type: "delete", text: midA[i] });
+      i++;
+    } else {
+      ops.push({ type: "insert", text: midB[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ type: "delete", text: midA[i++] });
+  while (j < m) ops.push({ type: "insert", text: midB[j++] });
+  for (let k = endA; k < a.length; k++) ops.push({ type: "equal", text: a[k] });
+  return ops;
+}
+var DIFF_CONTEXT = 3;
+function formatRange(start, count) {
+  const s = count === 0 ? start - 1 : start;
+  return count === 1 ? `${s}` : `${s},${count}`;
+}
+function unifiedDiff(a, b, path) {
+  if (a === b) return "";
+  const ops = diffOps(a.split("\n"), b.split("\n"));
+  const hunks = [];
+  let idx = 0;
+  while (idx < ops.length) {
+    if (ops[idx].type === "equal") {
+      idx++;
+      continue;
+    }
+    let start = idx;
+    let ctx = 0;
+    while (start > 0 && ops[start - 1].type === "equal" && ctx < DIFF_CONTEXT) {
+      start--;
+      ctx++;
+    }
+    let j = idx;
+    let equalRun = 0;
+    let lastChange = idx;
+    while (j < ops.length) {
+      if (ops[j].type === "equal") {
+        equalRun++;
+        if (equalRun > DIFF_CONTEXT * 2) break;
+      } else {
+        equalRun = 0;
+        lastChange = j;
+      }
+      j++;
+    }
+    let end = lastChange + 1;
+    ctx = 0;
+    while (end < ops.length && ops[end].type === "equal" && ctx < DIFF_CONTEXT) {
+      end++;
+      ctx++;
+    }
+    hunks.push({ start, ops: ops.slice(start, end) });
+    idx = end;
+  }
+  const out = [`--- a/${path}`, `+++ b/${path}`];
+  for (let h = 0; h < hunks.length; h++) {
+    const { start, ops: hunkOps } = hunks[h];
+    let oldCount = 0;
+    let newCount = 0;
+    for (let k = 0; k < start; k++) {
+      if (ops[k].type !== "insert") oldCount++;
+      if (ops[k].type !== "delete") newCount++;
+    }
+    let dels = 0;
+    let ins = 0;
+    for (const op of hunkOps) {
+      if (op.type === "delete") dels++;
+      else if (op.type === "insert") ins++;
+      else {
+        dels++;
+        ins++;
+      }
+    }
+    out.push(`@@ -${formatRange(oldCount + 1, dels)} +${formatRange(newCount + 1, ins)} @@`);
+    for (const op of hunkOps) {
+      const prefix = op.type === "equal" ? " " : op.type === "delete" ? "-" : "+";
+      out.push(prefix + op.text);
+    }
+  }
+  return out.join("\n") + "\n";
+}
+
+// src/emit/interface-emitter.ts
 var GENERATED_HEADER = "// @generated by nudo \u2014 do not edit; regenerate with `nudo contract --emit`";
 async function emitInterface(filePath, opts) {
   const abs = resolve2(filePath);
@@ -340,7 +565,7 @@ async function emitInterface(filePath, opts) {
       `emit target '${abs}' is inside node_modules; contract sidecars are never written there`
     );
   }
-  const proj = findProjectConfig(dirname3(abs));
+  const proj = findProjectConfig(dirname2(abs));
   const allow = interfaceConfig(proj?.config).emit;
   if (!matchesEmitAllowlist(abs, proj?.projectDir, allow)) {
     return {
@@ -351,24 +576,24 @@ async function emitInterface(filePath, opts) {
         {
           code: "nudo:interface-emit-denied",
           severity: "warning",
-          message: `emit target '${relative2(process.cwd(), abs) || abs}' is outside package.json#nudo.contract.emit allowlist`
+          message: `emit target '${relative(process.cwd(), abs) || abs}' is outside package.json#nudo.contract.emit allowlist`
         }
       ],
       sidecarPath: sidecarPathOf2(abs)
     };
   }
-  const source = opts.source ?? readFileSync3(abs, "utf-8");
+  const source = opts.source ?? readFileSync2(abs, "utf-8");
   const ifaceSince = interfaceDiagCount2();
   const refineSince = refineDiagCount2();
   const sidecarPath = sidecarPathOf2(abs);
-  const sidecarSrc = existsSync3(sidecarPath) ? readFileSync3(sidecarPath, "utf-8") : "";
-  const srcRel = relative2(dirname3(sidecarPath), abs) || basename(abs);
+  const sidecarSrc = existsSync2(sidecarPath) ? readFileSync2(sidecarPath, "utf-8") : "";
+  const srcRel = relative(dirname2(sidecarPath), abs) || basename(abs);
   const sections = collectGeneratedSections(sidecarSrc);
   const generatedNames = new Set(sections.flatMap((s) => s.names));
   const declared = topLevelDeclaredNames(sidecarSrc);
   if (declared === void 0) {
     throw new Error(
-      `sidecar '${relative2(process.cwd(), sidecarPath) || sidecarPath}' is not parseable; fix it before emitting`
+      `sidecar '${relative(process.cwd(), sidecarPath) || sidecarPath}' is not parseable; fix it before emitting`
     );
   }
   for (const n of generatedNames) declared.delete(n);
@@ -481,15 +706,15 @@ async function emitInterface(filePath, opts) {
     finalContent = joinSections(base, [...preserved, ...accepted.map((a) => a.text)]);
   }
   const changed = finalContent !== sidecarSrc;
-  const diff = changed ? unifiedDiff(sidecarSrc, finalContent, relative2(process.cwd(), sidecarPath) || sidecarPath) : void 0;
+  const diff = changed ? unifiedDiff(sidecarSrc, finalContent, relative(process.cwd(), sidecarPath) || sidecarPath) : void 0;
   if (changed && !opts.dryRun) {
     const tmp = `${sidecarPath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
     try {
-      writeFileSync2(tmp, finalContent, "utf-8");
+      writeFileSync(tmp, finalContent, "utf-8");
       renameSync(tmp, sidecarPath);
     } catch (e) {
       try {
-        if (existsSync3(tmp)) unlinkSync(tmp);
+        if (existsSync2(tmp)) unlinkSync(tmp);
       } catch {
       }
       throw e;
@@ -679,9 +904,9 @@ function joinSections(base, sectionTexts) {
   return lead + normalized.join("\n");
 }
 
-// src/interface-draft.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, realpathSync } from "fs";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join2, relative as relative3 } from "path";
+// src/emit/interface-draft.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, realpathSync } from "fs";
+import { basename as basename2, dirname as dirname3, isAbsolute, join, relative as relative2 } from "path";
 import {
   effectiveInterface as effectiveInterface2,
   formatConstraint as formatConstraint3,
@@ -692,12 +917,12 @@ import {
   localNamedExports as localNamedExports3,
   sidecarPathOf as sidecarPathOf3
 } from "@nudojs/core";
-import { parse } from "@nudojs/parser";
+import { parse as parse2 } from "@nudojs/parser";
 function collectParamBodyAccesses(source) {
   const out = /* @__PURE__ */ new Map();
   let ast;
   try {
-    ast = parse(source);
+    ast = parse2(source);
   } catch {
     return out;
   }
@@ -1059,7 +1284,7 @@ function suggestedBodyDsl(fnName, params) {
   return `//   suggested (body-read, not a contract): ${fnName} = fn({ ${parts.join(", ")} })`;
 }
 async function draftInterface(filePath, opts = {}) {
-  const source = opts.source ?? readFileSync4(filePath, "utf-8");
+  const source = opts.source ?? readFileSync3(filePath, "utf-8");
   const loadModule = opts.loadModule ?? defaultLoadModule;
   const sidecarPath = sidecarPathOf3(filePath);
   const wantBody = opts.bodyAccesses !== false;
@@ -1209,7 +1434,7 @@ function safeRealpath(p) {
     return realpathSync(p);
   } catch {
     try {
-      return join2(realpathSync(dirname4(p)), basename2(p));
+      return join(realpathSync(dirname3(p)), basename2(p));
     } catch {
       return p;
     }
@@ -1232,17 +1457,17 @@ function writeInterfaceDraft(filePath, draftSource, opts = {}) {
   if (opts.projectDir) {
     const rootReal = safeRealpath(opts.projectDir);
     const draftReal = safeRealpath(draftPath);
-    const rel = relative3(rootReal, draftReal);
-    if (rel.startsWith("..") || isAbsolute2(rel)) {
+    const rel = relative2(rootReal, draftReal);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
       throw new Error(`draft write refused: outside project root ${opts.projectDir}`);
     }
   }
   const draftable = opts.draftable !== void 0 ? opts.draftable : opts.entries !== void 0 ? isDraftableEntry(opts.entries) : /export\s+const\s+[\p{ID_Start}$_][\p{ID_Continue}$]*\s*=/u.test(draftSource);
-  const prev = existsSync4(draftPath) ? readFileSync4(draftPath, "utf-8") : void 0;
+  const prev = existsSync3(draftPath) ? readFileSync3(draftPath, "utf-8") : void 0;
   const changed = prev !== draftSource;
   const written = !opts.dryRun && changed && draftable;
   if (written) {
-    writeFileSync3(draftPath, draftSource, "utf-8");
+    writeFileSync2(draftPath, draftSource, "utf-8");
   }
   return {
     draftPath,
@@ -1288,10 +1513,10 @@ function formatDraftSummary(sourceRel, draftRel, result, write) {
   return lines;
 }
 
-// src/interface-derivation-derive.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { basename as basename3, dirname as dirname5, relative as relative4, resolve as resolve3 } from "path";
-import { parse as parse2 } from "@nudojs/parser";
+// src/emit/interface-derivation-derive.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { basename as basename3, dirname as dirname4, relative as relative3, resolve as resolve3 } from "path";
+import { parse as parse3 } from "@nudojs/parser";
 import {
   constraintToEntryAbs,
   effectiveInterface as effectiveInterface3,
@@ -1313,7 +1538,7 @@ import {
   tagDerivationRoot
 } from "@nudojs/core/internal";
 
-// src/interface-derivation-project.ts
+// src/emit/interface-derivation-project.ts
 import { formatConstraint as formatConstraint4, joinThenProject as joinThenProject3 } from "@nudojs/core";
 import { derivationChain, getDerivation, projectDerivationDsl } from "@nudojs/core/internal";
 function projectParamSlot(absList, paramName) {
@@ -1448,12 +1673,12 @@ function projectReturnRelativeToParams(node, params, paramNames) {
   return void 0;
 }
 
-// src/interface-derivation-derive.ts
+// src/emit/interface-derivation-derive.ts
 function extractFnConstraintSources(sidecarSrc, fnName) {
   const out = { params: {} };
   let ast;
   try {
-    ast = parse2(sidecarSrc);
+    ast = parse3(sidecarSrc);
   } catch {
     return out;
   }
@@ -1524,7 +1749,7 @@ function extractFnConstraintSources(sidecarSrc, fnName) {
 }
 function functionParamNames(source, fnName) {
   try {
-    const ast = parse2(source);
+    const ast = parse3(source);
     if (fnName.includes(".")) {
       const [clsName, methodName] = fnName.split(".", 2);
       for (const stmt of ast.program.body) {
@@ -1585,8 +1810,8 @@ function topLevelFnNames(source) {
 function importLocalMap(source, fromFile) {
   const out = /* @__PURE__ */ new Map();
   try {
-    const ast = parse2(source);
-    const base = dirname5(resolve3(fromFile));
+    const ast = parse3(source);
+    const base = dirname4(resolve3(fromFile));
     for (const stmt of ast.program.body) {
       if (stmt.type !== "ImportDeclaration") continue;
       const spec = stmt.source.value;
@@ -1594,7 +1819,7 @@ function importLocalMap(source, fromFile) {
       const raw = resolve3(base, spec);
       let modulePath = null;
       for (const cand of [raw, `${raw}.js`, `${raw}.ts`, `${raw}.mjs`]) {
-        if (existsSync5(cand)) {
+        if (existsSync4(cand)) {
           modulePath = cand;
           break;
         }
@@ -1613,12 +1838,12 @@ function importLocalMap(source, fromFile) {
 }
 function deriveFromRoot(filePath, opts = {}) {
   const abs = resolve3(filePath);
-  const source = readFileSync5(abs, "utf-8");
+  const source = readFileSync4(abs, "utf-8");
   const since = interfaceDiagCount3();
-  const autoBind = opts.autoBind ?? interfaceConfig(findProjectConfig(dirname5(abs))?.config).autoBind;
+  const autoBind = opts.autoBind ?? interfaceConfig(findProjectConfig(dirname4(abs))?.config).autoBind;
   const loadModule = opts.loadModule ?? defaultLoadModule;
   const sidecarPath = sidecarPathOf4(abs);
-  const sidecarSrc = existsSync5(sidecarPath) && !isNodeModulesPath2(sidecarPath) ? readFileSync5(sidecarPath, "utf-8") : "";
+  const sidecarSrc = existsSync4(sidecarPath) && !isNodeModulesPath2(sidecarPath) ? readFileSync4(sidecarPath, "utf-8") : "";
   const fnNames = topLevelFnNames(source);
   const roots = [];
   const plans = [];
@@ -1659,7 +1884,7 @@ function deriveFromRoot(filePath, opts = {}) {
   const wanted = opts.fnNames && opts.fnNames.length > 0 ? new Set(opts.fnNames) : void 0;
   const derived = [];
   for (const plan of plans) {
-    const relRoot = relative4(process.cwd(), abs);
+    const relRoot = relative3(process.cwd(), abs);
     const label = `${relRoot === "" || relRoot.startsWith("..") ? basename3(abs) : relRoot}:${plan.fnName}`;
     const rows = deriveOneRoot(plan, source, abs, modules, importLocals, label);
     for (const row of rows) {
@@ -1729,7 +1954,7 @@ function deriveOneRoot(plan, source, file, modules, importLocals, label) {
         targetFile = file;
       }
       if (isNodeModulesPath2(targetFile)) continue;
-      if (!existsSync5(targetFile)) continue;
+      if (!existsSync4(targetFile)) continue;
       const key = `${targetFile}::${targetExport}`;
       let agg = byCallee.get(key);
       if (!agg) {
@@ -1743,7 +1968,7 @@ function deriveOneRoot(plan, source, file, modules, importLocals, label) {
     for (const agg of byCallee.values()) {
       let targetSource;
       try {
-        targetSource = readFileSync5(agg.targetFile, "utf-8");
+        targetSource = readFileSync4(agg.targetFile, "utf-8");
       } catch {
         continue;
       }
@@ -1822,11 +2047,11 @@ function deriveOneRoot(plan, source, file, modules, importLocals, label) {
   }
 }
 
-// src/interface-derivation-rewrite.ts
-import { relative as relative5, resolve as resolve4 } from "path";
+// src/emit/interface-derivation-rewrite.ts
+import { relative as relative4, resolve as resolve4 } from "path";
 function resolveRelImport(fromSpec, fromDir, targetDir) {
   const abs = resolve4(fromDir, fromSpec);
-  let rel = relative5(targetDir, abs);
+  let rel = relative4(targetDir, abs);
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel.split("\\").join("/");
 }
@@ -1943,9 +2168,9 @@ function formatDerivedSection(row, opts) {
   return { text: lines.join("\n"), usedNames: [...usedNames] };
 }
 
-// src/interface-derivation-emit.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename4, dirname as dirname6, relative as relative6, resolve as resolve5 } from "path";
+// src/emit/interface-derivation-emit.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename4, dirname as dirname5, relative as relative5, resolve as resolve5 } from "path";
 import {
   execNudoModule as execNudoModule2,
   isNodeModulesPath as isNodeModulesPath3,
@@ -2011,10 +2236,10 @@ function emitDerivedFromRoot(rootFile, opts) {
   if (!derive.hasRoot) {
     return { sidecars: [], hasRoot: false, roots: [], entryOnly: true };
   }
-  const proj = findProjectConfig(dirname6(abs));
+  const proj = findProjectConfig(dirname5(abs));
   const allow = interfaceConfig(proj?.config).emit;
   const projectDir = proj?.projectDir;
-  const rootSidecarDir = dirname6(sidecarPathOf5(abs));
+  const rootSidecarDir = dirname5(sidecarPathOf5(abs));
   const wanted = opts.fnNames && opts.fnNames.length > 0 ? new Set(opts.fnNames) : void 0;
   const result = {
     sidecars: [],
@@ -2033,8 +2258,8 @@ function emitDerivedFromRoot(rootFile, opts) {
   }
   for (const [sidecarPath, rows0] of bySidecar) {
     const targetFile = rows0[0].file;
-    const targetSidecarDir = dirname6(sidecarPath);
-    const prevSrc = existsSync6(sidecarPath) ? readFileSync6(sidecarPath, "utf-8") : "";
+    const targetSidecarDir = dirname5(sidecarPath);
+    const prevSrc = existsSync5(sidecarPath) ? readFileSync5(sidecarPath, "utf-8") : "";
     const rows = opts.refreshExistingOnly ? rows0.filter((r) => findGeneratedSectionText(prevSrc, r.fn) !== void 0) : rows0;
     if (rows.length === 0) continue;
     const handwritten = handwrittenNames(prevSrc);
@@ -2053,7 +2278,7 @@ function emitDerivedFromRoot(rootFile, opts) {
         issues.push({
           code: "nudo:interface-name-clash",
           severity: "error",
-          message: `sidecar already has a handwritten binding '${row.fn}' (${relative6(process.cwd(), sidecarPath) || sidecarPath}); handwritten wins \u2014 skipping emit`
+          message: `sidecar already has a handwritten binding '${row.fn}' (${relative5(process.cwd(), sidecarPath) || sidecarPath}); handwritten wins \u2014 skipping emit`
         });
         anySkip = "name-clash";
         continue;
@@ -2081,7 +2306,7 @@ function emitDerivedFromRoot(rootFile, opts) {
         continue;
       }
       for (const n of body.usedNames) taken.add(n);
-      const srcRel = relative6(targetSidecarDir, targetFile) || basename4(targetFile);
+      const srcRel = relative5(targetSidecarDir, targetFile) || basename4(targetFile);
       const section = [
         DERIVED_HEADER,
         `// source: ${srcRel}:${row.fn}`,
@@ -2131,7 +2356,7 @@ function emitDerivedFromRoot(rootFile, opts) {
       issues.push({
         code: "nudo:interface-not-projectable",
         severity: "error",
-        message: `assembled sidecar failed round-trip (${relative6(process.cwd(), sidecarPath) || sidecarPath}); refusing to write`
+        message: `assembled sidecar failed round-trip (${relative5(process.cwd(), sidecarPath) || sidecarPath}); refusing to write`
       });
       anySkip = "not-projectable";
       result.sidecars.push({
@@ -2146,15 +2371,15 @@ function emitDerivedFromRoot(rootFile, opts) {
       continue;
     }
     const changed = finalContent !== prevSrc;
-    const diff = changed ? unifiedDiff(prevSrc, finalContent, relative6(process.cwd(), sidecarPath) || sidecarPath) : void 0;
+    const diff = changed ? unifiedDiff(prevSrc, finalContent, relative5(process.cwd(), sidecarPath) || sidecarPath) : void 0;
     if (changed && !opts.dryRun) {
       const tmp = `${sidecarPath}.tmp-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
       try {
-        writeFileSync4(tmp, finalContent, "utf-8");
+        writeFileSync3(tmp, finalContent, "utf-8");
         renameSync2(tmp, sidecarPath);
       } catch (e) {
         try {
-          if (existsSync6(tmp)) unlinkSync2(tmp);
+          if (existsSync5(tmp)) unlinkSync2(tmp);
         } catch {
         }
         throw e;
@@ -2305,115 +2530,1218 @@ function derivedRoundTrips(text, fn, fromFile, loadModule) {
   }
 }
 
-// src/what-if.ts
-import { parse as parse3 } from "@nudojs/parser";
-function splitTopLevelUnion(expr) {
-  const members = [];
-  let start = 0;
-  let depth = 0;
-  for (let i = 0; i < expr.length; i++) {
-    const c = expr[i];
-    if (c === "(" || c === "[" || c === "{") depth++;
-    else if (c === ")" || c === "]" || c === "}") depth--;
-    else if (c === "|" && depth === 0) {
-      members.push(expr.slice(start, i));
-      start = i + 1;
-    }
-  }
-  members.push(expr.slice(start));
-  return members.map((m) => m.trim()).filter(Boolean);
-}
-function typeExprToDirective(expr) {
-  const members = splitTopLevelUnion(expr);
-  if (members.length === 0) return "any()";
-  const mapped = members.map((m) => {
-    if (m.startsWith("T.")) return "any()";
-    if (m === "number" || m === "string" || m === "boolean") return `${m}()`;
-    if (m === "unknown" || m === "any") return "any()";
-    if (m === "null" || m === "undefined" || m === "true" || m === "false") return m;
-    if (/^-?\d+(\.\d+)?$/.test(m)) return m;
-    if (/^["']/.test(m)) return m;
-    if (/[([{]|=>/.test(m) && !m.startsWith("T.")) return m;
-    if (/^(number|string|boolean|any|array|shape|lit|union|fn)\s*\(/.test(m)) return m;
-    return "any()";
-  });
-  return mapped.length === 1 ? mapped[0] : `union(${mapped.join(", ")})`;
+// src/emit/dts-generator.ts
+import { joinAbs, litValue, abs as makeAbs, collectAbsFreeVars } from "@nudojs/core";
+import { isTemplateLike, templatePartsOf } from "@nudojs/core/internal";
+function tsTypeParamName(id) {
+  let n = id.replace(/[^A-Za-z0-9_$]/g, "_");
+  if (!/^[A-Za-z_$]/.test(n)) n = `T_${n}`;
+  if (n.length === 0) n = "T";
+  return n;
+}
+function wrapComplexAbs(a, typeVars) {
+  const ts = absToTSType(a, typeVars);
+  if (a.shape.k === "sum" || a.shape.k === "fn") return `(${ts})`;
+  return ts;
+}
+function wrapUnionMember(a, typeVars) {
+  const ts = absToTSType(a, typeVars);
+  if (a.shape.k === "fn") return `(${ts})`;
+  return ts;
+}
+var TS_PARAM_RESERVED = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "static",
+  "await",
+  "implements",
+  "interface",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "arguments",
+  "eval",
+  "constructor"
+]);
+function isTsIdent(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !TS_PARAM_RESERVED.has(name);
+}
+function sanitizeParamName(name, index) {
+  if (name.startsWith("...")) {
+    const rest = name.slice(3);
+    if (isTsIdent(rest)) return name;
+    return `...arg${index}`;
+  }
+  if (isTsIdent(name)) return name;
+  return `arg${index}`;
+}
+function formatPropKey(k) {
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k)) return k;
+  if (/^\d+$/.test(k)) return k;
+  return JSON.stringify(k);
+}
+function absToTSType(a, typeVars) {
+  if (a.shape.k === "any" && a.term?.op === "var" && typeVars) {
+    const mapped = typeVars.get(a.term.id);
+    if (mapped) return mapped;
+  }
+  if (a.shape.k === "arr" && a.shape.element.shape.k === "any" && a.shape.element.term?.op === "var" && typeVars) {
+    const mapped = typeVars.get(a.shape.element.term.id);
+    if (mapped) return `${mapped}[]`;
+  }
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (v === null) return "null";
+    if (v === void 0) return "undefined";
+    if (a.shape.k === "prim") {
+      if (typeof v === "string") return JSON.stringify(v);
+      if (typeof v === "boolean") return String(v);
+      if (typeof v === "number") return String(v);
+    }
+  }
+  if (a.shape.k === "prim" && a.shape.type === "string" && isTemplateLike(a)) {
+    const parts = templatePartsOf(a);
+    const inner = parts.map((p) => {
+      const lv = litValue(p);
+      if (typeof lv === "string") return lv;
+      return `\${${absToTSType(p, typeVars)}}`;
+    }).join("");
+    return `\`${inner}\``;
+  }
+  switch (a.shape.k) {
+    case "never":
+      return "never";
+    case "unknown":
+    case "any":
+      return "unknown";
+    case "prim":
+      return a.shape.type;
+    case "obj": {
+      const entries = Object.entries(a.shape.slots).map(([k, slot]) => {
+        const inner = absToTSType(slot.value, typeVars);
+        if (slot.optional) {
+          const t = wrapComplexAbs(slot.value, typeVars);
+          return `${formatPropKey(k)}: ${t} | undefined`;
+        }
+        return `${formatPropKey(k)}: ${inner}`;
+      });
+      if (entries.length === 0) return "{}";
+      return `{ ${entries.join("; ")} }`;
+    }
+    case "arr":
+      return `${wrapComplexAbs(a.shape.element, typeVars)}[]`;
+    case "tuple": {
+      const parts = a.shape.elements.map((e) => absToTSType(e, typeVars));
+      if (a.shape.rest) {
+        const rest = a.shape.rest;
+        const restTs = rest.shape.k === "arr" ? absToTSType(rest, typeVars) : `${absToTSType(rest, typeVars)}[]`;
+        parts.push(`...${restTs}`);
+      }
+      return `[${parts.join(", ")}]`;
+    }
+    case "fn": {
+      const paramTypes = a.shape.paramTypes;
+      const params = a.shape.params.map((p, i) => {
+        const isRest = p.startsWith("...");
+        const name = sanitizeParamName(p, i);
+        const pt = paramTypes?.[i];
+        let typeStr;
+        if (pt) typeStr = absToTSType(pt, typeVars);
+        else if (isRest) typeStr = "unknown[]";
+        else typeStr = "unknown";
+        return `${name}: ${typeStr}`;
+      }).join(", ");
+      const ret = a.shape.returnType ? absToTSType(a.shape.returnType, typeVars) : "unknown";
+      return `(${params}) => ${ret}`;
+    }
+    case "brand":
+      return isTsIdent(a.shape.name) || /^[A-Z][A-Za-z0-9_$]*$/.test(a.shape.name) ? a.shape.name : "unknown";
+    case "eff":
+      if (a.shape.eff === "promise")
+        return `Promise<${absToTSType(a.shape.inner, typeVars)}>`;
+      return absToTSType(a.shape.inner, typeVars);
+    case "sum": {
+      const parts = a.shape.members.map((m) => wrapUnionMember(m, typeVars)).filter((p) => p !== "never");
+      const uniq = [...new Set(parts)];
+      if (uniq.length === 0) return "never";
+      if (uniq.length === 1) return uniq[0];
+      return uniq.join(" | ");
+    }
+    default:
+      return "unknown";
+  }
+}
+function caseArgAbs(c, i) {
+  return c.argAbs[i];
+}
+function caseResultAbs(c) {
+  return c.abs;
+}
+function widenParamAbs(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "prim":
+      return makeAbs(s, void 0, void 0, "exact");
+    case "tuple": {
+      const widened = s.elements.map(widenParamAbs);
+      const first = widened[0];
+      if (first && widened.length > 0 && widened.every((el) => absToTSType(el) === absToTSType(first))) {
+        return makeAbs({ k: "arr", element: first }, void 0, void 0, "exact");
+      }
+      return makeAbs({ k: "tuple", elements: widened }, void 0, void 0, "exact");
+    }
+    case "arr":
+      return makeAbs({ k: "arr", element: widenParamAbs(s.element) }, void 0, void 0, "exact");
+    case "obj": {
+      const slots = {};
+      for (const [k, slot] of Object.entries(s.slots)) {
+        slots[k] = {
+          value: widenParamAbs(slot.value),
+          ...slot.optional ? { optional: true } : {}
+        };
+      }
+      return makeAbs({ k: "obj", slots }, void 0, void 0, "exact");
+    }
+    case "eff":
+      return makeAbs(
+        { k: "eff", eff: s.eff, inner: widenParamAbs(s.inner) },
+        void 0,
+        void 0,
+        "exact"
+      );
+    case "brand":
+      return makeAbs(
+        { k: "brand", name: s.name, shape: widenParamAbs(s.shape) },
+        void 0,
+        void 0,
+        "exact"
+      );
+    case "sum":
+      return makeAbs(
+        { k: "sum", members: s.members.map(widenParamAbs) },
+        void 0,
+        void 0,
+        "exact"
+      );
+    default:
+      return a;
+  }
 }
-function declaredNames(stmt, out) {
-  if (stmt.type === "FunctionDeclaration" && stmt.id) out.add(stmt.id.name);
-  else if (stmt.type === "ClassDeclaration" && stmt.id) out.add(stmt.id.name);
-  else if (stmt.type === "VariableDeclaration") {
-    for (const decl of stmt.declarations) {
-      if (decl.id?.type === "Identifier") out.add(decl.id.name);
+function widenTopLevelAbs(a) {
+  if (a.shape.k === "sum") {
+    return makeAbs(
+      { k: "sum", members: a.shape.members.map(widenTopLevelAbs) },
+      void 0,
+      void 0,
+      a.conf
+    );
+  }
+  return widenLiteralToPrimAbs(a);
+}
+function widenLiteralToPrimAbs(a) {
+  if (a.term?.op === "lit" && a.term.value === null) return a;
+  if (a.term?.op === "lit" && a.term.value === void 0) return a;
+  if (a.term?.op === "lit" && a.shape.k === "prim") {
+    const v = a.term.value;
+    if (typeof v === "number" || typeof v === "string" || typeof v === "boolean" || typeof v === "bigint") {
+      return makeAbs(a.shape, void 0, void 0, a.conf);
     }
-  } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
-    declaredNames(stmt.declaration, out);
   }
+  return a;
 }
-function injectBindings(source, bindings) {
-  const applied = [];
-  const unapplied = [];
-  if (bindings.length === 0) return { source, applied, unapplied };
-  const ast = parse3(source);
-  const declLines = /* @__PURE__ */ new Map();
-  for (const stmt of ast.program.body) {
-    const names = /* @__PURE__ */ new Set();
-    declaredNames(stmt, names);
-    if (names.size === 0 || !stmt.loc) continue;
-    const anchorLine = stmt.leadingComments?.[0]?.loc?.start.line ?? stmt.loc.start.line;
-    for (const name of names) {
-      if (!declLines.has(name)) declLines.set(name, anchorLine);
-    }
-  }
-  const byLine = /* @__PURE__ */ new Map();
-  for (const binding of bindings) {
-    const line = declLines.get(binding.name);
-    if (line === void 0) {
-      unapplied.push(binding.name);
+function paramTypeFromAbs(members) {
+  if (members.length === 0) return "unknown";
+  let joined;
+  try {
+    joined = members.reduce((a, b) => joinAbs(a, b));
+  } catch {
+    joined = members[0];
+  }
+  return absToTSType(widenParamAbs(joined));
+}
+function returnAbsOf(fn) {
+  if (fn.combinedAbs) return fn.combinedAbs;
+  const results = fn.cases.map(caseResultAbs);
+  if (results.length > 0) {
+    try {
+      return results.reduce((a, b) => joinAbs(a, b));
+    } catch {
+    }
+    return results[0];
+  }
+  return void 0;
+}
+function getParamName(fn, index) {
+  if (fn.paramNames && fn.paramNames[index]) {
+    return fn.paramNames[index];
+  }
+  return `arg${index}`;
+}
+function computeMainSignature(fn) {
+  const arity = Math.max(...fn.cases.map((c) => c.argAbs.length));
+  const minArity = Math.min(...fn.cases.map((c) => c.argAbs.length));
+  const params = [];
+  const paramNames = [];
+  const paramTypes = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < arity; i++) {
+    const members = [];
+    for (const c of fn.cases) {
+      if (i >= c.argAbs.length) continue;
+      const a = caseArgAbs(c, i);
+      if (a) members.push(a);
+    }
+    const typeStr = paramTypeFromAbs(members);
+    let name = getParamName(fn, i);
+    const isRest = name.startsWith("...");
+    const bare = isRest ? name.slice(3) : name;
+    if (!isTsIdent(bare)) {
+      name = isRest ? `...arg${i}` : `arg${i}`;
+    }
+    if (usedNames.has(name)) {
+      let n = 2;
+      while (usedNames.has(`${name}${n}`)) n++;
+      name = `${name}${n}`;
+    }
+    usedNames.add(name);
+    const optional = i >= minArity && !isRest;
+    params.push(optional ? `${name}?: ${typeStr}` : `${name}: ${typeStr}`);
+    paramNames.push(name);
+    paramTypes.push(typeStr);
+  }
+  const retAbs = returnAbsOf(fn);
+  const returnType = retAbs ? absToTSType(widenTopLevelAbs(retAbs)) : "unknown";
+  return { params, paramNames, paramTypes, returnType };
+}
+function generateJSDoc(fn, sig) {
+  if (fn.cases.length === 0) return "";
+  const lines = ["/**"];
+  for (const c of fn.cases) {
+    const preciseDiffers = c.argAbs.length !== sig.paramTypes.length || c.argAbs.some((a, i) => absToTSType(a) !== sig.paramTypes[i]) || absToTSType(c.abs) !== sig.returnType;
+    if (!preciseDiffers) continue;
+    const argsStr = c.argAbs.map((a) => absToTSType(a)).join(", ");
+    lines.push(` * Case: ${c.name} (${argsStr}) => ${absToTSType(c.abs)}`);
+  }
+  for (let i = 0; i < sig.paramTypes.length; i++) {
+    lines.push(` * @param ${sig.paramNames[i]} - ${sig.paramTypes[i]}`);
+  }
+  lines.push(` * @returns ${sig.returnType}`);
+  lines.push(" */");
+  return lines.join("\n");
+}
+function computeHofSignature(fn) {
+  const hof = fn.hof;
+  if (!hof) return void 0;
+  const byParam = /* @__PURE__ */ new Map();
+  for (const s of hof.entryShapes ?? []) byParam.set(s.param, s.abs);
+  for (const r of hof.fnRels ?? []) byParam.set(r.param, r.abs);
+  if (byParam.size === 0 && !hof.symbolic) return void 0;
+  if (fn.cases.length > 0) {
+    for (const [param] of byParam) {
+      const idx = fn.paramNames.indexOf(param);
+      if (idx < 0) continue;
+      const caseType = paramTypeFromAbs(
+        fn.cases.map((c) => c.argAbs[idx]).filter((a) => !!a)
+      );
+      if (caseType !== "unknown" && caseType !== "unknown[]") {
+        return void 0;
+      }
+    }
+  }
+  const arity = Math.max(
+    fn.paramNames.length,
+    ...[...byParam.keys()].map((p) => fn.paramNames.indexOf(p) + 1),
+    0
+  );
+  if (arity === 0 && !hof.symbolic) return void 0;
+  const free = /* @__PURE__ */ new Set();
+  for (const a of byParam.values()) {
+    for (const id of collectAbsFreeVars(a)) free.add(id);
+  }
+  const retAbs = hof.symbolic ?? fn.combinedAbs;
+  if (retAbs) {
+    for (const id of collectAbsFreeVars(retAbs)) free.add(id);
+  }
+  if (free.size === 0) return void 0;
+  const typeVars = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  const typeParams = [];
+  for (const id of [...free].sort()) {
+    let n = tsTypeParamName(id);
+    if (used.has(n) || TS_PARAM_RESERVED.has(n)) {
+      let i = 2;
+      while (used.has(`${n}${i}`)) i++;
+      n = `${n}${i}`;
+    }
+    used.add(n);
+    typeVars.set(id, n);
+    typeParams.push(n);
+  }
+  const params = [];
+  const paramNames = [];
+  const paramTypes = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < arity; i++) {
+    const rawName = getParamName(fn, i);
+    const isRest = rawName.startsWith("...");
+    let name = sanitizeParamName(rawName, i);
+    if (usedNames.has(name)) {
+      let n = 2;
+      while (usedNames.has(`${name}${n}`)) n++;
+      name = isRest && name.startsWith("...") ? `...${name.slice(3)}${n}` : `${name}${n}`;
+    }
+    usedNames.add(name);
+    const promoted = byParam.get(fn.paramNames[i] ?? rawName) ?? byParam.get(rawName);
+    const typeStr = promoted ? absToTSType(promoted, typeVars) : isRest ? "unknown[]" : "unknown";
+    params.push(`${name}: ${typeStr}`);
+    paramNames.push(name);
+    paramTypes.push(typeStr);
+  }
+  const returnType = retAbs ? absToTSType(retAbs, typeVars) : "unknown";
+  return { typeParams, params, paramNames, paramTypes, returnType };
+}
+function generateFunctionDtsLines(fn) {
+  let emitFn = fn;
+  if (fn.noDeclaration) {
+    const m = /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(fn.name);
+    if (!m) return [];
+    emitFn = { ...fn, name: `${m[1]}_${m[2]}`, noDeclaration: false };
+  }
+  fn = emitFn;
+  const hofSig = computeHofSignature(fn);
+  if (hofSig) {
+    const lines2 = [];
+    if (fn.cases.length > 0) {
+      const jsdoc2 = generateJSDoc(fn, {
+        params: hofSig.params,
+        paramNames: hofSig.paramNames,
+        paramTypes: hofSig.paramTypes,
+        returnType: hofSig.returnType
+      });
+      if (jsdoc2) lines2.push(jsdoc2);
+    }
+    const tparams = hofSig.typeParams.length > 0 ? `<${hofSig.typeParams.join(", ")}>` : "";
+    lines2.push(
+      `export declare function ${fn.name}${tparams}(${hofSig.params.join(", ")}): ${hofSig.returnType};`
+    );
+    return lines2;
+  }
+  if (fn.cases.length === 0) {
+    const retAbs = fn.combinedAbs;
+    if (retAbs) {
+      return [
+        `export declare function ${fn.name}(...args: unknown[]): ${absToTSType(retAbs)};`
+      ];
+    }
+    return [];
+  }
+  const sig = computeMainSignature(fn);
+  const jsdoc = generateJSDoc(fn, sig);
+  const lines = [];
+  if (jsdoc) lines.push(jsdoc);
+  lines.push(`export declare function ${fn.name}(${sig.params.join(", ")}): ${sig.returnType};`);
+  return lines;
+}
+function generateDts(result) {
+  const lines = [];
+  for (const fn of result.functions) {
+    lines.push(...generateFunctionDtsLines(fn));
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/emit/schema-generator.ts
+import { absToConstraint, isIntFlag as isIntFlag2, predToString } from "@nudojs/core";
+function predLeaves(p) {
+  if (!p || p.op === "true") return [];
+  if (p.op === "and") {
+    const out = [];
+    for (const x of p.args) {
+      const sub = predLeaves(x);
+      if (sub === "unexpressible") return "unexpressible";
+      out.push(...sub);
+    }
+    return out;
+  }
+  if (p.op === "or" || p.op === "not" || p.op === "false") return "unexpressible";
+  return [p];
+}
+function isSelfVar(t) {
+  return !!t && t.op === "var";
+}
+function litOf(t) {
+  return t && t.op === "lit" ? t.value : void 0;
+}
+function eqLitValue(p) {
+  if (p.op !== "eq") return "unanchored";
+  const aLit = litOf(p.a);
+  const bLit = litOf(p.b);
+  if (aLit !== void 0 && (isSelfVar(p.b) || p.b.op === "app")) return aLit;
+  if (bLit !== void 0 && (isSelfVar(p.a) || p.a.op === "app")) return bLit;
+  if (aLit !== void 0 && bLit !== void 0) return aLit === bLit ? aLit : "unanchored";
+  return "unanchored";
+}
+function isIntModOne(p) {
+  if (p.op !== "eq") return false;
+  const zero = (t) => !!t && t.op === "lit" && t.value === 0;
+  const isModOne = (t) => !!t && t.op === "app" && t.fn === "%" && t.args.length === 2 && t.args[1]?.op === "lit" && t.args[1].value === 1 && (isSelfVar(t.args[0]) || t.args[0].op === "app");
+  return isModOne(p.a) && zero(p.b) || isModOne(p.b) && zero(p.a);
+}
+function numericBound(p, allowSelfVar) {
+  if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le") return "drop";
+  const n = litOf(p.b);
+  if (typeof n !== "number") return "drop";
+  if (p.a.op === "app" && p.a.fn === "length") return "skip";
+  if (allowSelfVar && isSelfVar(p.a)) return { op: p.op, n };
+  if (p.a.op === "app" && (p.a.fn === "get" || p.a.fn === "length")) return "skip";
+  return "drop";
+}
+function lengthBound(p) {
+  if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le") return void 0;
+  if (p.a.op !== "app" || p.a.fn !== "length") return void 0;
+  const n = litOf(p.b);
+  if (typeof n !== "number") return void 0;
+  if (p.op === "ge") return { dir: "min", n: Math.ceil(n) };
+  if (p.op === "gt") return { dir: "min", n: Math.floor(n) + 1 };
+  if (p.op === "le") return { dir: "max", n: Math.floor(n) };
+  return { dir: "max", n: Math.ceil(n) - 1 };
+}
+function refinementsFromPreds(preds, opts) {
+  const refinements = [];
+  const dropped = [];
+  let eqLit;
+  for (const p of preds) {
+    if (p.op === "typeof") continue;
+    if (p.op === "eq") {
+      if (opts.kind === "number" && isIntModOne(p)) {
+        if (!refinements.some((r) => r.kind === "int")) refinements.push({ kind: "int" });
+        continue;
+      }
+      const v = eqLitValue(p);
+      if (v === "unanchored") {
+        dropped.push(`pred not projected: ${predToString(p)}`);
+        continue;
+      }
+      if (typeof v === "number" && Number.isNaN(v)) {
+        dropped.push(`pred not projected (NaN): ${predToString(p)}`);
+        continue;
+      }
+      if (eqLit !== void 0 && eqLit !== v) {
+        dropped.push(`conflicting eq preds: ${predToString(p)}`);
+        continue;
+      }
+      eqLit = v;
       continue;
     }
-    const group = byLine.get(line) ?? [];
-    group.push(binding);
-    byLine.set(line, group);
-    applied.push(binding.name);
+    if (p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") {
+      if (opts.kind === "string") {
+        const lb = lengthBound(p);
+        if (lb) {
+          refinements.push(lb.dir === "min" ? { kind: "strMin", n: lb.n } : { kind: "strMax", n: lb.n });
+          continue;
+        }
+        dropped.push(`pred not projected: ${predToString(p)}`);
+        continue;
+      }
+      const b = numericBound(p, opts.kind === "number" || opts.kind === "other");
+      if (b === "skip") continue;
+      if (b === "drop") {
+        dropped.push(`pred not projected: ${predToString(p)}`);
+        continue;
+      }
+      if (opts.kind === "number" || opts.kind === "other") {
+        refinements.push({ kind: "numBound", op: b.op, n: b.n });
+        continue;
+      }
+      dropped.push(`pred not projected: ${predToString(p)}`);
+      continue;
+    }
+    dropped.push(`pred not projected: ${predToString(p)}`);
   }
-  const insertions = [];
-  for (const [line, group] of byLine) {
-    insertions.push({
-      index: line - 1,
-      text: `// @nudo:as ${typeExprToDirective(group[0].type)}`
-    });
+  return { refinements, ...eqLit !== void 0 ? { eqLit } : {}, dropped };
+}
+function constraintToSchemaNode(c) {
+  if (c.fn) return { k: "fn" };
+  if (c.members) {
+    return { k: "union", members: c.members.map(constraintToSchemaNode) };
   }
-  insertions.sort((a, b) => b.index - a.index);
-  const lines = source.split("\n");
-  for (const ins of insertions) lines.splice(ins.index, 0, ins.text);
-  return { source: lines.join("\n"), applied, unapplied };
+  if (c.fields) {
+    return {
+      k: "obj",
+      slots: Object.entries(c.fields).map(([key, field]) => ({
+        key,
+        node: constraintToSchemaNode(field.constraint),
+        ...field.optional || field.constraint.isOptional ? { optional: true } : {}
+      }))
+    };
+  }
+  if (c.element) {
+    return { k: "arr", element: constraintToSchemaNode(c.element) };
+  }
+  const preds = c.preds ?? [];
+  const kind = c.prim === "number" ? "number" : c.prim === "string" ? "string" : c.prim === "boolean" ? "boolean" : c.prim ? "other" : "other";
+  const { refinements, eqLit, dropped } = refinementsFromPreds(preds, { kind });
+  if (eqLit !== void 0 && (kind === "number" || kind === "string" || kind === "boolean" || !c.prim)) {
+    return { k: "lit", value: eqLit };
+  }
+  if (isIntFlag2(c) && !refinements.some((r) => r.kind === "int")) {
+    refinements.push({ kind: "int" });
+  }
+  void dropped;
+  if (!c.prim) {
+    if (Object.keys(c.fields ?? {}).length === 0 && !c.element && !c.members) {
+      return { k: "unknown" };
+    }
+  }
+  const type = c.prim === "number" || c.prim === "string" || c.prim === "boolean" || c.prim === "bigint" || c.prim === "symbol" ? c.prim : "unknown";
+  if (type === "unknown") return { k: "unknown" };
+  return { k: "prim", type, refinements };
+}
+function constraintDropped(c, prefix = "") {
+  const out = [];
+  const visit = (n, path) => {
+    if (n.fields) {
+      for (const [k, f] of Object.entries(n.fields)) visit(f.constraint, path ? `${path}.${k}` : k);
+      return;
+    }
+    if (n.members) {
+      n.members.forEach((m, i) => visit(m, `${path}[${i}]`));
+      return;
+    }
+    if (n.element) {
+      visit(n.element, `${path}[]`);
+      return;
+    }
+    if (n.fn) return;
+    const kind = n.prim === "number" ? "number" : n.prim === "string" ? "string" : n.prim === "boolean" ? "boolean" : "other";
+    const { eqLit, dropped } = refinementsFromPreds(n.preds ?? [], { kind });
+    for (const d of dropped) out.push(path ? `${path}: ${d}` : d);
+    if (eqLit === void 0 && n.preds?.some((p) => p.op === "eq") && !isIntFlag2(n)) {
+    }
+  };
+  visit(c, prefix);
+  return out;
+}
+function absToSchemaNode(a) {
+  const dropped = [];
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (typeof v === "number" && Number.isNaN(v)) {
+      dropped.push("lit NaN not projected");
+    } else if (v === null || v === void 0 || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      return { node: { k: "lit", value: v }, dropped };
+    } else if (typeof v === "bigint") {
+      dropped.push(`lit bigint not projected: ${String(v)}`);
+      return { node: { k: "unknown" }, dropped };
+    }
+  }
+  const conf = a.conf;
+  const lowConf = conf !== "exact" && conf !== "path";
+  const projected = absToConstraint(a);
+  if (projected) {
+    const node = constraintToSchemaNode(projected);
+    dropped.push(...constraintDropped(projected));
+    return { node, dropped };
+  }
+  if (lowConf) {
+    dropped.push(`conf=${conf}: contract projection skipped; shape-only fallback`);
+  }
+  const s = a.shape;
+  switch (s.k) {
+    case "never":
+      return { node: { k: "never" }, dropped };
+    case "any":
+    case "unknown":
+      return { node: { k: "unknown" }, dropped };
+    case "prim": {
+      const kind = s.type === "number" ? "number" : s.type === "string" ? "string" : s.type === "boolean" ? "boolean" : "other";
+      const leaves = predLeaves(a.pred);
+      if (leaves === "unexpressible") {
+        if (a.pred && a.pred.op !== "true") {
+          dropped.push(`pred not projected: ${predToString(a.pred)}`);
+        }
+        return { node: { k: "prim", type: s.type, refinements: [] }, dropped };
+      }
+      const { refinements, eqLit, dropped: d } = refinementsFromPreds(leaves, { kind });
+      dropped.push(...d);
+      if (eqLit !== void 0 && !Number.isNaN(eqLit)) {
+        return { node: { k: "lit", value: eqLit }, dropped };
+      }
+      return { node: { k: "prim", type: s.type, refinements }, dropped };
+    }
+    case "obj": {
+      if (s.open || s.index) {
+        dropped.push("open/index object not fully projected (known slots only)");
+      }
+      if (a.pred && a.pred.op !== "true") {
+        dropped.push(`obj pred not projected: ${predToString(a.pred)}`);
+      }
+      const slots = [];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const sub = absToSchemaNode(slot.value);
+        dropped.push(...sub.dropped.map((n) => `${key}: ${n}`));
+        slots.push({ key, node: sub.node, ...slot.optional ? { optional: true } : {} });
+      }
+      return { node: { k: "obj", slots }, dropped };
+    }
+    case "arr": {
+      if (a.pred && a.pred.op !== "true") {
+        dropped.push(`arr pred not projected: ${predToString(a.pred)}`);
+      }
+      const sub = absToSchemaNode(s.element);
+      dropped.push(...sub.dropped);
+      return { node: { k: "arr", element: sub.node }, dropped };
+    }
+    case "tuple": {
+      const elements = s.elements.map((e) => {
+        const sub = absToSchemaNode(e);
+        dropped.push(...sub.dropped);
+        return sub.node;
+      });
+      return { node: { k: "tuple", elements }, dropped };
+    }
+    case "sum": {
+      const members = s.members.map((m) => {
+        const sub = absToSchemaNode(m);
+        dropped.push(...sub.dropped);
+        return sub.node;
+      });
+      return { node: { k: "union", members }, dropped };
+    }
+    case "fn":
+      return { node: { k: "fn" }, dropped };
+    case "eff": {
+      const inner = absToSchemaNode(s.inner);
+      dropped.push(...inner.dropped);
+      return {
+        node: s.eff === "promise" ? { k: "promise", inner: inner.node } : inner.node,
+        dropped
+      };
+    }
+    case "brand":
+      return { node: { k: "brand", name: s.name }, dropped };
+    default:
+      return { node: { k: "unknown" }, dropped };
+  }
+}
+function zodApplyRefinements(base, refinements) {
+  let out = base;
+  if (refinements.some((r) => r.kind === "int")) out += ".int()";
+  for (const r of refinements) {
+    switch (r.kind) {
+      case "numBound":
+        if (r.op === "gt") out += `.gt(${r.n})`;
+        else if (r.op === "ge") out += `.gte(${r.n})`;
+        else if (r.op === "lt") out += `.lt(${r.n})`;
+        else out += `.lte(${r.n})`;
+        break;
+      case "strMin":
+        out += `.min(${r.n})`;
+        break;
+      case "strMax":
+        out += `.max(${r.n})`;
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function schemaNodeToZod(node) {
+  switch (node.k) {
+    case "lit": {
+      const v = node.value;
+      if (v === null) return "z.null()";
+      if (v === void 0) return "z.undefined()";
+      if (typeof v === "string") return `z.literal(${JSON.stringify(v)})`;
+      if (typeof v === "boolean") return `z.literal(${v})`;
+      if (typeof v === "number") return `z.literal(${v})`;
+      return "z.unknown()";
+    }
+    case "prim":
+      return zodApplyRefinements(`z.${node.type}()`, node.refinements);
+    case "obj": {
+      const entries = node.slots.map((slot) => {
+        const inner = schemaNodeToZod(slot.node);
+        return `${slot.key}: ${slot.optional ? `${inner}.optional()` : inner}`;
+      }).join(", ");
+      return `z.object({ ${entries} })`;
+    }
+    case "arr":
+      return `z.array(${schemaNodeToZod(node.element)})`;
+    case "tuple":
+      return `z.tuple([${node.elements.map(schemaNodeToZod).join(", ")}])`;
+    case "union":
+      return `z.union([${node.members.map(schemaNodeToZod).join(", ")}])`;
+    case "fn":
+      return "z.function()";
+    case "promise":
+      return `z.promise(${schemaNodeToZod(node.inner)})`;
+    case "brand":
+      return `z.instanceof(${node.name})`;
+    case "never":
+      return "z.never()";
+    case "unknown":
+    default:
+      return "z.unknown()";
+  }
+}
+var DIALECT_RENDERERS = {
+  zod: schemaNodeToZod
+};
+function projectAbsToSchema(a, opts) {
+  const dialect = opts?.dialect ?? "zod";
+  const { node, dropped } = absToSchemaNode(a);
+  const render = DIALECT_RENDERERS[dialect] ?? schemaNodeToZod;
+  return { source: render(node), dialect, dropped };
+}
+function absToSchemaSource(a, opts) {
+  return projectAbsToSchema(a, opts).source;
 }
 
+// src/emit/standard-schema.ts
+function pushIssue(issues, path, message) {
+  issues.push(path.length > 0 ? { message, path: [...path] } : { message });
+}
+function typeOf(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function checkPrimRefinements(refinements, value, path, issues) {
+  if (typeof value !== "number" && typeof value !== "string") return;
+  for (const r of refinements) {
+    if (r.kind === "int") {
+      if (typeof value === "number" && !Number.isInteger(value)) {
+        pushIssue(issues, path, "expected integer");
+      }
+      continue;
+    }
+    if (r.kind === "numBound" && typeof value === "number" && typeof r.n === "number") {
+      const n = r.n;
+      const op = r.op;
+      let ok = true;
+      if (op === "gt") ok = value > n;
+      else if (op === "ge") ok = value >= n;
+      else if (op === "lt") ok = value < n;
+      else if (op === "le") ok = value <= n;
+      if (!ok) pushIssue(issues, path, `expected number ${op} ${n}, got ${value}`);
+      continue;
+    }
+    if (r.kind === "strMin" && typeof value === "string" && typeof r.n === "number") {
+      if (value.length < r.n) {
+        pushIssue(issues, path, `expected string length >= ${r.n}, got ${value.length}`);
+      }
+      continue;
+    }
+    if (r.kind === "strMax" && typeof value === "string" && typeof r.n === "number") {
+      if (value.length > r.n) {
+        pushIssue(issues, path, `expected string length <= ${r.n}, got ${value.length}`);
+      }
+    }
+  }
+}
+function checkNode(node, value, path, issues) {
+  switch (node.k) {
+    case "unknown":
+    case "fn":
+    case "brand":
+    case "promise":
+      return;
+    case "never":
+      pushIssue(issues, path, "expected never");
+      return;
+    case "lit": {
+      const expected = node.value;
+      const same = expected === value || typeof expected === "number" && typeof value === "number" && Number.isNaN(expected) && Number.isNaN(value);
+      if (!same) {
+        pushIssue(issues, path, `expected ${JSON.stringify(expected)}, got ${JSON.stringify(value)}`);
+      }
+      return;
+    }
+    case "prim": {
+      const t = node.type;
+      const actual = typeOf(value);
+      const ok = t === "number" && actual === "number" || t === "string" && actual === "string" || t === "boolean" && actual === "boolean" || t === "bigint" && actual === "bigint" || t === "symbol" && actual === "symbol";
+      if (!ok) {
+        pushIssue(issues, path, `expected ${t}, got ${actual}`);
+        return;
+      }
+      checkPrimRefinements(node.refinements, value, path, issues);
+      return;
+    }
+    case "obj": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        pushIssue(issues, path, `expected object, got ${typeOf(value)}`);
+        return;
+      }
+      const rec = value;
+      for (const slot of node.slots) {
+        const key = slot.key;
+        if (!(key in rec) || rec[key] === void 0) {
+          if (!slot.optional) pushIssue(issues, [...path, key], "required");
+          continue;
+        }
+        checkNode(slot.node, rec[key], [...path, key], issues);
+      }
+      return;
+    }
+    case "arr": {
+      if (!Array.isArray(value)) {
+        pushIssue(issues, path, `expected array, got ${typeOf(value)}`);
+        return;
+      }
+      value.forEach((item, i) => {
+        checkNode(node.element, item, [...path, i], issues);
+      });
+      return;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) {
+        pushIssue(issues, path, `expected tuple, got ${typeOf(value)}`);
+        return;
+      }
+      node.elements.forEach((el, i) => {
+        checkNode(el, value[i], [...path, i], issues);
+      });
+      return;
+    }
+    case "union": {
+      for (const m of node.members) {
+        const local = [];
+        checkNode(m, value, path, local);
+        if (local.length === 0) return;
+      }
+      pushIssue(
+        issues,
+        path,
+        `expected one of ${node.members.length} union members, got ${typeOf(value)}`
+      );
+      return;
+    }
+    case "promise": {
+      return;
+    }
+    default:
+      return;
+  }
+}
+function validateSchemaNode(node, value) {
+  const issues = [];
+  checkNode(node, value, [], issues);
+  return issues.length === 0 ? { value } : { issues };
+}
+var CHECK_FN_SOURCE = `
+function __nudoTypeOf(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function __nudoCheck(node, value, path, issues) {
+  function push(msg) {
+    issues.push(path.length > 0 ? { message: msg, path: path.slice() } : { message: msg });
+  }
+  switch (node.k) {
+    case "unknown":
+    case "summarized":
+    case "fn":
+    case "brand":
+    case "promise":
+      return;
+    case "never":
+      push("expected never");
+      return;
+    case "lit": {
+      const expected = node.value;
+      const same = expected === value ||
+        (typeof expected === "number" && typeof value === "number" &&
+          Number.isNaN(expected) && Number.isNaN(value));
+      if (!same) push("expected " + JSON.stringify(expected) + ", got " + JSON.stringify(value));
+      return;
+    }
+    case "prim": {
+      const t = node.type;
+      const actual = __nudoTypeOf(value);
+      const ok =
+        (t === "number" && actual === "number") ||
+        (t === "string" && actual === "string") ||
+        (t === "boolean" && actual === "boolean") ||
+        (t === "bigint" && actual === "bigint") ||
+        (t === "symbol" && actual === "symbol");
+      if (!ok) { push("expected " + t + ", got " + actual); return; }
+      for (const r of node.refinements || []) {
+        if (r.kind === "int" && typeof value === "number" && !Number.isInteger(value)) {
+          push("expected integer");
+        } else if (r.kind === "numBound" && typeof value === "number" && typeof r.n === "number") {
+          var okB = true;
+          if (r.op === "gt") okB = value > r.n;
+          else if (r.op === "ge") okB = value >= r.n;
+          else if (r.op === "lt") okB = value < r.n;
+          else if (r.op === "le") okB = value <= r.n;
+          if (!okB) push("expected number " + r.op + " " + r.n + ", got " + value);
+        } else if (r.kind === "strMin" && typeof value === "string" && typeof r.n === "number") {
+          if (value.length < r.n) push("expected string length >= " + r.n + ", got " + value.length);
+        } else if (r.kind === "strMax" && typeof value === "string" && typeof r.n === "number") {
+          if (value.length > r.n) push("expected string length <= " + r.n + ", got " + value.length);
+        }
+      }
+      return;
+    }
+    case "obj": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        push("expected object, got " + __nudoTypeOf(value));
+        return;
+      }
+      for (const slot of node.slots) {
+        const key = slot.key;
+        if (!(key in value) || value[key] === undefined) {
+          if (!slot.optional) { path.push(key); push("required"); path.pop(); }
+          continue;
+        }
+        path.push(key);
+        __nudoCheck(slot.node, value[key], path, issues);
+        path.pop();
+      }
+      return;
+    }
+    case "arr": {
+      if (!Array.isArray(value)) { push("expected array, got " + __nudoTypeOf(value)); return; }
+      for (let i = 0; i < value.length; i++) {
+        path.push(i);
+        __nudoCheck(node.element, value[i], path, issues);
+        path.pop();
+      }
+      return;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) { push("expected tuple, got " + __nudoTypeOf(value)); return; }
+      for (let i = 0; i < node.elements.length; i++) {
+        path.push(i);
+        __nudoCheck(node.elements[i], value[i], path, issues);
+        path.pop();
+      }
+      return;
+    }
+    case "union": {
+      for (const m of node.members) {
+        const local = [];
+        __nudoCheck(m, value, path, local);
+        if (local.length === 0) return;
+      }
+      push("expected one of " + node.members.length + " union members, got " + __nudoTypeOf(value));
+      return;
+    }
+    default:
+      return;
+  }
+}
+`.trim();
+function makeStandardSchemaSource(exportName, node, dropped) {
+  const json = JSON.stringify(node);
+  const notes = dropped.length > 0 ? dropped.map((d) => `//   ${d}`).join("\n") + "\n" : "";
+  return `${notes}export const ${exportName} = {
+  "~standard": {
+    version: 1,
+    vendor: "nudo",
+    validate(value) {
+      const issues = [];
+      __nudoCheck(${json}, value, [], issues);
+      return issues.length ? { issues } : { value };
+    },
+  },
+} as const;`;
+}
+function absToStandardSchemaModule(exports, opts) {
+  const dropped = [];
+  const bodies = [];
+  for (const [name, abs] of Object.entries(exports)) {
+    const { node, dropped: d } = absToSchemaNode(abs);
+    dropped.push(...d.map((n) => `${name}: ${n}`));
+    bodies.push(makeStandardSchemaSource(name, node, d.map((n) => `${name}: ${n}`)));
+  }
+  const banner = opts?.banner ?? `// @generated by nudo export --format standard \u2014 Standard Schema v1 (vendor: nudo)
+// One-way lossy projection of Abs; do not edit. nudo check remains the gate.`;
+  const source = `${banner}
+
+${CHECK_FN_SOURCE}
+
+${bodies.join("\n\n")}
+`;
+  return { source, dropped };
+}
+function absToStandardSchema(a, opts) {
+  return absToStandardSchemaModule({ [opts?.name ?? "schema"]: a });
+}
+
+// src/emit/guard-generator.ts
+import { denoteGuard } from "@nudojs/core/internal";
+function generateGuardFunctionFromAbs(name, abs) {
+  const body = denoteGuard(abs, "data");
+  return `export function ${name}(data) {
+  return ${body};
+}`;
+}
+function generateGuardFunction(name, abs) {
+  return generateGuardFunctionFromAbs(name, abs);
+}
+
+// src/emit/case-json.ts
+import { formatAbs, formatShape as formatShape3 } from "@nudojs/core";
+function mapCase(c) {
+  const out = {
+    name: c.name,
+    args: c.argAbs.map((a) => formatShape3(a)),
+    result: formatShape3(c.abs),
+    throws: c.throwsAbs.shape.k !== "never" ? formatShape3(c.throwsAbs) : null,
+    source: c.source ?? null
+  };
+  if (c.aggregatedFrom !== void 0) out.aggregatedFrom = c.aggregatedFrom;
+  if (c.argAbs.length > 0) {
+    out.argsAbs = c.argAbs.map((a) => {
+      try {
+        return formatAbs(a);
+      } catch {
+        return "unknown";
+      }
+    });
+  }
+  try {
+    out.resultAbs = formatAbs(c.abs);
+  } catch {
+  }
+  if (c.intension) {
+    const i = c.intension;
+    out.intension = {
+      ...i.display !== void 0 ? { display: i.display } : {},
+      ...i.abs !== void 0 ? { abs: i.abs } : {},
+      ...i.absMultiline !== void 0 ? { absMultiline: i.absMultiline } : {},
+      ...i.term !== void 0 ? { term: i.term } : {},
+      ...i.pred !== void 0 ? { pred: i.pred } : {},
+      ...i.conf !== void 0 ? { conf: i.conf } : {}
+    };
+  }
+  return out;
+}
+function mapFunction(f) {
+  const out = {
+    name: f.name,
+    loc: f.loc,
+    entryOnly: f.entryOnly ?? false,
+    cases: f.cases.map(mapCase)
+  };
+  if (f.noDeclaration) out.noDeclaration = true;
+  if (f.combinedAbs) {
+    out.combined = formatShape3(f.combinedAbs);
+    try {
+      out.combinedAbs = formatAbs(f.combinedAbs);
+    } catch {
+    }
+  }
+  return out;
+}
+function serializeCaseJson(result, file) {
+  const functions = result.functions.map(mapFunction);
+  const external = result.externalFunctions?.map((f) => ({
+    name: f.name,
+    fromModule: f.fromModule,
+    cases: f.cases.map(mapCase)
+  }));
+  const caseCount = functions.reduce((n, f) => n + f.cases.length, 0) + (external ?? []).reduce((n, f) => n + f.cases.length, 0);
+  const json = {
+    version: 1,
+    file,
+    summary: {
+      functions: functions.length,
+      externalFunctions: external?.length ?? 0,
+      cases: caseCount,
+      diagnostics: result.diagnostics.length
+    },
+    functions,
+    diagnostics: result.diagnostics.map((d) => ({
+      range: d.range,
+      severity: d.severity,
+      message: d.message,
+      ...d.code !== void 0 ? { code: d.code } : {},
+      ...d.suggestions ? { suggestions: d.suggestions } : {},
+      ...d.tags ? { tags: d.tags } : {},
+      ...d.origin ? { origin: d.origin } : {}
+    }))
+  };
+  if (external) json.externalFunctions = external;
+  return json;
+}
 export {
-  collectLoadDepContents,
-  ANALYSIS_ABI,
-  sha256Hex,
-  relativizePath,
-  DiskCache,
-  checkCacheKey,
-  ifaceCacheKey,
-  extractNudoImportSpecs,
-  formatInterfaceSurfaceLine,
-  interfaceSurface,
-  emitInterface,
-  formatEmitSummary,
+  absToSchemaNode,
+  absToSchemaSource,
+  absToStandardSchema,
+  absToStandardSchemaModule,
+  absToTSType,
+  buildCaseDirective,
   collectParamBodyAccesses,
+  constraintToSchemaNode,
+  deriveFromRoot,
   draftInterface,
-  formatDraftModule,
-  sidecarDraftPath,
-  isDraftableEntry,
-  writeInterfaceDraft,
-  formatDraftSummary,
+  emitDerivedFromRoot,
+  emitInterface,
   extractFnConstraintSources,
-  deriveFromRoot,
   formatDerivedSection,
-  emitDerivedFromRoot,
+  formatDraftModule,
+  formatDraftSummary,
+  formatEmitSummary,
+  formatInterfaceSurfaceLine,
+  generateDts,
+  generateFunctionDtsLines,
+  generateGuardFunction,
+  generateGuardFunctionFromAbs,
+  injectBindings,
+  insertGeneratedCaseDirectives,
+  interfaceSurface,
+  isDraftableEntry,
+  projectAbsToSchema,
+  schemaNodeToZod,
+  serializeCaseArg,
+  serializeCaseJson,
+  sidecarDraftPath,
+  stripGeneratedCaseDirectives,
   typeExprToDirective,
-  injectBindings
+  unifiedDiff,
+  validateSchemaNode,
+  writeInterfaceDraft
 };