@nudojs/service 3.0.0 → 5.0.0-beta.0

package/dist/chunk-YLVZMHWC.js

@@ -0,0 +1,364 @@
+// src/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";
+}
+
+export {
+  serializeCaseArg,
+  buildCaseDirective,
+  stripGeneratedCaseDirectives,
+  insertGeneratedCaseDirectives,
+  unifiedDiff
+};

package/dist/{config-Cqj8zeZH.d.ts → config-DDB588oA.d.ts}

@@ -1,51 +1,8 @@
-import { Abs, Environment } from '@nudojs/core';
-
-/**
- * 调用点记录（CallRecord）。Abs 唯一真理源。
- * argAbs/resultAbs/throwsAbs 必填；展示/外延在 CaseResult 边界再桥。
- */
-
-type CallRecord = {
-    fnName: string;
-    /** 无损参数 Abs */
-    argAbs: Abs[];
-    /** 无损结果 Abs（threw 时为 never） */
-    resultAbs: Abs;
-    /** 无损抛出值 Abs（未抛为 never） */
-    throwsAbs: Abs;
-    /** Line-relative. Per-fn cache replay shifts this by lineDelta — if you
-     *  add another position field (callee loc, arg loc), extend
-     *  shiftCallRecordLines in analyzer.ts in the same change. */
-    callLoc?: {
-        line: number;
-        column: number;
-    };
-    targetModule?: string;
-    targetExport?: string;
-    /** export names the same function value was re-exported under after its
-     * defining module (barrel `index.js`, CJS forwarding shims); usage-site
-     * records stay name-matchable against them */
-    targetAliases?: string[];
-    /** module whose evaluation created the function value (definition site). */
-    fnModule?: string;
-};
-
-type LoadedEnv = {
-    /** Abs 原生模块导出（B 路径 / Abs 模块图） */
-    modules: Record<string, Record<string, Abs>>;
-    globals: Record<string, Abs>;
-};
-/** Host cache-clear hooks (CLI watch / vite / tests) must drop path-env modules too */
-declare function clearPathEnvCaches(): void;
-declare function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void>;
-declare function loadEnvsAsync(envNames: string[], globalEnv: Environment, baseDir?: string): Promise<LoadedEnv>;
-declare function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv;
-
 type NudoConfig = {
     env?: string[];
     mocks?: Record<string, string>;
-    interface?: {
-        /** 侧车 ambient 绑定总开关（check/LSP 执法与 interface 打印共用） */
+    contract?: {
+        /** 侧车 ambient 绑定总开关（check/LSP 执法与 contract 打印共用） */
         autoBind?: boolean;
         /**
          * emit 白名单（Phase 3，§7.3）：glob 数组，相对 projectDir。
@@ -53,7 +10,7 @@ type NudoConfig = {
          */
         emit?: string[] | string;
     };
-    /** 分析范围与噪声档（design-analysis-scope.md / A2） */
+    /** 分析范围与噪声档（design-cli-semantics.md §7） */
     analysis?: {
         include?: string[] | string;
         exclude?: string[] | string;
@@ -65,9 +22,30 @@ type NudoConfig = {
         callSiteBudget?: number;
         /** C0.5：求值命中闭对象缺字段 → nudo:missing-slot；默认 off */
         evalMissingSlot?: "off" | "warning";
+        /**
+         * B $fork 总次数上限（默认 5000）。env `NUDO_MAX_FORKS` 优先。
+         * n≥1 有限整数；非法值回默认。启动时 set 进 core（setBForkBudgetLimit）。
+         */
+        maxForks?: number;
     };
     /** 磁盘缓存（B3）：true → `.nudo/cache`；字符串 → 自定义根；false/省略 → 关 */
     cache?: boolean | string;
+    /**
+     * 进程内会话 LRU 上限（内存/速度权衡）。多项目开 IDE 时调低封顶；
+     * 单大仓 warm 命中可调高。0 = 关闭该层。env `NUDO_CACHE_MAX_*` 优先。
+     */
+    sessionCache?: {
+        maxFiles?: number;
+        maxFns?: number;
+        maxBRuns?: number;
+    };
+    /** check 门禁（design-cli-semantics §3） */
+    check?: {
+        /** L2 入口 may-throw：error | warning | off（默认 error） */
+        entryThrows?: "error" | "warning" | "off";
+        /** L2 --ignore-throws 类型名列表 */
+        ignoreThrows?: string[];
+    };
 };
 type InterfaceConfig = {
     autoBind: boolean;
@@ -85,7 +63,17 @@ type AnalysisConfig = {
     callSiteBudget: number;
     /** C0.5 evaluation-driven missing-slot；默认 off */
     evalMissingSlot: "off" | "warning";
+    /** B $fork 总次数上限（已归一化；非法值回 core 默认） */
+    maxForks: number;
+};
+type CheckConfig = {
+    /** L2 入口 may-throw 执法档；默认 error */
+    entryThrows: "error" | "warning" | "off";
+    /** L2 ignoreThrows 类型名；默认空 */
+    ignoreThrows: string[];
 };
+/** package.json#nudo.check → 执法选项 */
+declare function checkConfig(config: NudoConfig | null | undefined): CheckConfig;
 /** A1 产品默认：exports — 普通带导出的 .js 进 IDE；directives/all 需显式 */
 declare const DEFAULT_ANALYSIS_MODE: AnalysisMode;
 /**
@@ -95,10 +83,19 @@ declare const DEFAULT_ANALYSIS_MODE: AnalysisMode;
  * include 空 = 不按路径过滤（isNudoTargetPath 已管扩展名）。
  */
 declare function analysisConfig(config: NudoConfig | null | undefined): AnalysisConfig;
+/**
+ * 把 fork 预算写进 core（core 保持无 IO）。
+ * 优先级：env `NUDO_MAX_FORKS` > `package.json#nudo.analysis.maxForks` > 默认 5000。
+ * 约定：n≥1 有限整数；非法值回默认。返回实际生效值。
+ * 由 findProjectConfig / 宿主启动时调用（与 setSessionCacheFromProject 同时机）。
+ */
+declare function applyBForkBudgetFromConfig(config: NudoConfig | null | undefined, env?: NodeJS.ProcessEnv): number;
+/** 当前生效 fork 上限（调试/测试；与 core getBForkBudgetLimit 同源） */
+declare function currentBForkBudgetLimit(): number;
 /** 磁盘缓存根（B3）：config.cache / NUDO_CACHE_DIR / 默认关 */
 declare function diskCacheRoot(config: NudoConfig | null | undefined, projectDir: string | undefined): string | undefined;
 /**
- * 归一化 `nudo.interface` 配置段。
+ * 归一化 `nudo.contract` 配置段。
  * - autoBind 默认 true
  * - emit：string | string[] → string[]（空 = 不限制路径）
  */
@@ -114,4 +111,4 @@ declare function findProjectConfig(startDir: string): {
     projectDir: string;
 } | null;
 
-export { type AnalysisConfig as A, type CallRecord as C, type DiagnosticsLevel as D, type InterfaceConfig as I, type LoadedEnv as L, type NudoConfig as N, type AnalysisMode as a, DEFAULT_ANALYSIS_MODE as b, analysisConfig as c, clearPathEnvCaches as d, diskCacheRoot as e, findProjectConfig as f, loadEnvsAsync as g, interfaceConfig as i, loadEnvs as l, matchesEmitAllowlist as m, preloadPathEnvs as p };
+export { type AnalysisConfig as A, type CheckConfig as C, type DiagnosticsLevel as D, type InterfaceConfig as I, type NudoConfig as N, type AnalysisMode as a, analysisConfig as b, checkConfig as c, diskCacheRoot as d, DEFAULT_ANALYSIS_MODE as e, findProjectConfig as f, applyBForkBudgetFromConfig as g, currentBForkBudgetLimit as h, interfaceConfig as i, matchesEmitAllowlist as m };

package/dist/dts.d.ts

@@ -0,0 +1,142 @@
+import { Abs, NudoConstraint } from '@nudojs/core';
+import { a as AnalysisResult, F as FunctionAnalysis } from './analyzer-types-JyJiCt8w.js';
+import '@babel/types';
+
+/**
+ * Abs → TS 类型串。有损：pred / 非 lit term 落到 shape 基类型。
+ * `typeVars`：term var id → TS 类型参数名（HOF 泛型投影时传入；
+ * `any`+var 在此映射下渲染为该参数名，否则 `unknown`）。
+ */
+declare function absToTSType(a: Abs, typeVars?: Map<string, string>): string;
+/**
+ * 为单个函数生成 .d.ts 声明行（JSDoc + 单一 widen 主签名）。
+ * 有 hof 关系时优先泛型投影（C3.3）；否则 case-widen。
+ * service 的 generateDts 与 CLI `--dts`（infer/watch）共用本函数，
+ * 两条路径输出保持一致。
+ */
+declare function generateFunctionDtsLines(fn: FunctionAnalysis): string[];
+declare function generateDts(result: AnalysisResult): string;
+
+/**
+ * Abs → 生态 schema 投影（单向有损）。
+ *
+ * 优先走 core `absToConstraint`（与 interface/check 同一投影语义），
+ * 再转成中间层 SchemaNode；投影失败时退回 shape 尽力提取并记 dropped。
+ * Dialect 只负责 Node → 源码字符串；Abs 才是真理源。
+ */
+
+type SchemaDialect = "zod";
+type SchemaRefinement = {
+    kind: "numBound";
+    op: "gt" | "ge" | "lt" | "le";
+    n: number;
+} | {
+    kind: "int";
+} | {
+    kind: "strMin";
+    n: number;
+} | {
+    kind: "strMax";
+    n: number;
+};
+type SchemaNode = {
+    k: "lit";
+    value: string | number | boolean | null | undefined;
+} | {
+    k: "prim";
+    type: "number" | "string" | "boolean" | "bigint" | "symbol";
+    refinements: SchemaRefinement[];
+} | {
+    k: "obj";
+    slots: Array<{
+        key: string;
+        node: SchemaNode;
+        optional?: boolean;
+    }>;
+} | {
+    k: "arr";
+    element: SchemaNode;
+} | {
+    k: "tuple";
+    elements: SchemaNode[];
+} | {
+    k: "union";
+    members: SchemaNode[];
+} | {
+    k: "fn";
+} | {
+    k: "promise";
+    inner: SchemaNode;
+} | {
+    k: "brand";
+    name: string;
+} | {
+    k: "never";
+} | {
+    k: "unknown";
+};
+type SchemaProjection = {
+    source: string;
+    dialect: SchemaDialect;
+    dropped: string[];
+};
+/** NudoConstraint → SchemaNode（与 absToConstraint 投影语义对齐） */
+declare function constraintToSchemaNode(c: NudoConstraint): SchemaNode;
+/** Abs → SchemaNode + dropped（优先 core absToConstraint；失败则 shape 尽力） */
+declare function absToSchemaNode(a: Abs): {
+    node: SchemaNode;
+    dropped: string[];
+};
+declare function schemaNodeToZod(node: SchemaNode): string;
+declare function projectAbsToSchema(a: Abs, opts?: {
+    dialect?: SchemaDialect;
+}): SchemaProjection;
+declare function absToSchemaSource(a: Abs, opts?: {
+    dialect?: SchemaDialect;
+}): string;
+
+/**
+ * Abs / SchemaNode → Standard Schema v1 运行时模块（单向有损投影）。
+ *
+ * 产物是零第三方依赖的 TS/JS 模块：每个导出实现 `~standard` Props
+ * （version=1, vendor="nudo", validate）。validate 对 SchemaNode 做
+ * 结构 + 可表达 refinement 执法；落不了的 pred 不在此假装精确。
+ *
+ * 协议：https://standardschema.dev —— 运行时互操作出口，不替代 nudo check。
+ */
+
+type StandardSchemaIssue = {
+    message: string;
+    path?: ReadonlyArray<PropertyKey>;
+};
+type StandardSchemaResult = {
+    value: unknown;
+    issues?: undefined;
+} | {
+    issues: ReadonlyArray<StandardSchemaIssue>;
+    value?: undefined;
+};
+/** SchemaNode 同步校验（生成模块与测试共用语义）。 */
+declare function validateSchemaNode(node: SchemaNode, value: unknown): StandardSchemaResult;
+type StandardSchemaModuleProjection = {
+    source: string;
+    dropped: string[];
+};
+/**
+ * Abs → Standard Schema v1 模块源码。
+ * `exports`：导出名 → Abs（通常是 output / 各参数）。
+ */
+declare function absToStandardSchemaModule(exports: Record<string, Abs>, opts?: {
+    banner?: string;
+}): StandardSchemaModuleProjection;
+/** 便捷：单个 Abs → 单导出模块（默认导出名 `schema`）。 */
+declare function absToStandardSchema(a: Abs, opts?: {
+    name?: string;
+}): StandardSchemaModuleProjection;
+
+/** Abs 指称守卫（设计 §2.7）：保留 pred */
+declare function generateGuardFunctionFromAbs(name: string, abs: Abs): string;
+/** 兼容别名：Abs 路径唯一 */
+declare function generateGuardFunction(name: string, abs: Abs): string;
+
+export { type SchemaDialect, type SchemaNode, type SchemaProjection, type SchemaRefinement, type StandardSchemaIssue, type StandardSchemaModuleProjection, type StandardSchemaResult, absToSchemaNode, absToSchemaSource, absToStandardSchema, absToStandardSchemaModule, absToTSType, constraintToSchemaNode, generateDts, generateFunctionDtsLines, generateGuardFunction, generateGuardFunctionFromAbs, projectAbsToSchema, schemaNodeToZod, validateSchemaNode };

package/dist/dts.js

@@ -0,0 +1,30 @@
+import {
+  absToSchemaNode,
+  absToSchemaSource,
+  absToStandardSchema,
+  absToStandardSchemaModule,
+  absToTSType,
+  constraintToSchemaNode,
+  generateDts,
+  generateFunctionDtsLines,
+  generateGuardFunction,
+  generateGuardFunctionFromAbs,
+  projectAbsToSchema,
+  schemaNodeToZod,
+  validateSchemaNode
+} from "./chunk-6IZR4ZYJ.js";
+export {
+  absToSchemaNode,
+  absToSchemaSource,
+  absToStandardSchema,
+  absToStandardSchemaModule,
+  absToTSType,
+  constraintToSchemaNode,
+  generateDts,
+  generateFunctionDtsLines,
+  generateGuardFunction,
+  generateGuardFunctionFromAbs,
+  projectAbsToSchema,
+  schemaNodeToZod,
+  validateSchemaNode
+};

package/dist/env-loader-fj0TSCcA.d.ts

@@ -0,0 +1,20 @@
+import { Abs, Environment } from '@nudojs/core';
+
+type LoadedEnv = {
+    /** Abs 原生模块导出（B 路径 / Abs 模块图） */
+    modules: Record<string, Record<string, Abs>>;
+    globals: Record<string, Abs>;
+};
+/** 测试/诊断：path-env 驻留规模（均 ≤ 对应上限） */
+declare function getPathEnvCacheSizes(): {
+    byKey: number;
+    byPath: number;
+    baseDirs: number;
+};
+/** Host cache-clear hooks (CLI watch / vite / tests) must drop path-env modules too */
+declare function clearPathEnvCaches(): void;
+declare function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void>;
+declare function loadEnvsAsync(envNames: string[], globalEnv: Environment, baseDir?: string): Promise<LoadedEnv>;
+declare function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv;
+
+export { type LoadedEnv as L, loadEnvsAsync as a, clearPathEnvCaches as c, getPathEnvCacheSizes as g, loadEnvs as l, preloadPathEnvs as p };