@nudojs/service 3.0.0 → 5.0.0-beta.0

package/dist/chunk-6IZR4ZYJ.js

@@ -0,0 +1,1107 @@
+// src/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 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);
+    }
+  }
+  return a;
+}
+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/schema-generator.ts
+import { absToConstraint, isIntFlag, 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;
+    }
+    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)}`);
+  }
+  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) };
+  }
+  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 (isIntFlag(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") && !isIntFlag(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/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/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);
+}
+
+export {
+  absToTSType,
+  generateFunctionDtsLines,
+  generateDts,
+  constraintToSchemaNode,
+  absToSchemaNode,
+  schemaNodeToZod,
+  projectAbsToSchema,
+  absToSchemaSource,
+  validateSchemaNode,
+  absToStandardSchemaModule,
+  absToStandardSchema,
+  generateGuardFunctionFromAbs,
+  generateGuardFunction
+};