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

package/dist/{chunk-YLALZXTZ.js → chunk-ZXVAX7DE.js}

@@ -225,8 +225,246 @@ function builtinProtoMember(className, member) {
   return table[member] ?? null;
 }
 
+// src/evaluator/env-loader.ts
+import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolvePath, join as joinPath } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { defineEnv as defineEsEnv } from "@nudojs/env/es";
+import { defineEnv as defineWebEnv } from "@nudojs/env/web";
+import { defineEnv as defineNodeEnv } from "@nudojs/env/node";
+
+// src/lru-map.ts
+var BoundedLruMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max) {
+    this.max = max;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** 当前上限（可动态收紧；收紧时立刻按 LRU 压到新上限） */
+  getMax() {
+    return this.max;
+  }
+  setMax(max) {
+    this.max = max;
+    this.trim();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const hit = this.map.get(key);
+    if (hit === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, hit);
+    return hit;
+  }
+  /** 命中不改变 LRU 序（只读探测） */
+  peek(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    if (this.max <= 0) return;
+    while (this.map.size >= this.max && !this.map.has(key)) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+    this.map.delete(key);
+    this.map.set(key, value);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** 压到当前 max（调低上限时收内存） */
+  trim() {
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+  }
+};
+
+// src/evaluator/env-loader.ts
+var envFactories = {
+  es: defineEsEnv,
+  web: defineWebEnv,
+  node: defineNodeEnv
+};
+var impliedDeps = {
+  web: ["es"],
+  node: ["es"]
+};
+function resolveEnvNames(names) {
+  const resolved = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (resolved.has(name)) return;
+    const deps = impliedDeps[name];
+    if (deps) deps.forEach(visit);
+    resolved.add(name);
+  };
+  names.forEach(visit);
+  return [...resolved];
+}
+var PATH_ENV_CACHE_MAX = 64;
+var PATH_ENV_BY_PATH_MAX = 64;
+var PATH_ENV_BASE_DIRS_MAX = 64;
+var pathEnvCache = new BoundedLruMap(PATH_ENV_CACHE_MAX);
+var pathEnvByPath = new BoundedLruMap(PATH_ENV_BY_PATH_MAX);
+var pathEnvBaseDirs = /* @__PURE__ */ new Set();
+function addPathEnvBaseDir(baseDir) {
+  pathEnvBaseDirs.delete(baseDir);
+  pathEnvBaseDirs.add(baseDir);
+  while (pathEnvBaseDirs.size > PATH_ENV_BASE_DIRS_MAX) {
+    const oldest = pathEnvBaseDirs.values().next().value;
+    if (oldest === void 0) break;
+    pathEnvBaseDirs.delete(oldest);
+  }
+}
+function getPathEnvCacheSizes() {
+  return {
+    byKey: pathEnvCache.size,
+    byPath: pathEnvByPath.size,
+    baseDirs: pathEnvBaseDirs.size
+  };
+}
+function isPathEnvName(name, baseDir) {
+  if (name in envFactories) return false;
+  if (name.includes("/") || name.startsWith("./") || name.startsWith("../")) return true;
+  const resolved = resolvePath(baseDir, name);
+  return resolved.endsWith(".ts") && existsSync(resolved);
+}
+function rewriteBareImports(text) {
+  const require2 = createRequire(import.meta.url);
+  let rewrote = false;
+  const out = text.replace(/(["'])(@nudojs\/[a-z0-9-]+)\1/g, (_m, quote, spec) => {
+    try {
+      const entry = require2.resolve(spec);
+      const url = pathToFileURL(entry).href;
+      rewrote = true;
+      return `${quote}${url}${quote}`;
+    } catch {
+      return `${quote}${spec}${quote}`;
+    }
+  });
+  return rewrote ? out : null;
+}
+async function importPathEnv(resolvedPath, mtimeMs) {
+  const cacheKey = `${resolvedPath}:${mtimeMs}`;
+  if (pathEnvCache.get(cacheKey)) return;
+  let mod = null;
+  try {
+    const url = pathToFileURL(resolvedPath).href + `?mtime=${mtimeMs}`;
+    mod = await import(url);
+  } catch {
+    mod = null;
+  }
+  if (!mod) {
+    try {
+      const text = readFileSync(resolvedPath, "utf-8");
+      const rewritten = rewriteBareImports(text);
+      if (rewritten === null) return;
+      const cacheDir = joinPath(tmpdir(), "nudo-env");
+      mkdirSync(cacheDir, { recursive: true });
+      const hash = createHash("md5").update(`${resolvedPath}:${mtimeMs}`).digest("hex").slice(0, 16);
+      const copyPath = joinPath(cacheDir, `${hash}.ts`);
+      writeFileSync(copyPath, rewritten, "utf-8");
+      mod = await import(pathToFileURL(copyPath).href);
+    } catch {
+      return;
+    }
+  }
+  if (mod && typeof mod.defineEnv === "function") {
+    pathEnvCache.set(cacheKey, mod.defineEnv);
+    pathEnvByPath.set(resolvedPath, {
+      factory: mod.defineEnv,
+      mtimeMs
+    });
+  }
+}
+function lookupPathEnv(name) {
+  if (pathEnvByPath.size === 0) return void 0;
+  const candidates = name.startsWith("/") ? [name] : [name, ...[...pathEnvBaseDirs].map((d) => resolvePath(d, name))];
+  for (const candidate of candidates) {
+    const hit = pathEnvByPath.get(candidate);
+    if (!hit) continue;
+    try {
+      const { mtimeMs } = statSync(candidate);
+      if (mtimeMs !== hit.mtimeMs) {
+        pathEnvByPath.delete(candidate);
+        return void 0;
+      }
+    } catch {
+      pathEnvByPath.delete(candidate);
+      return void 0;
+    }
+    return hit.factory;
+  }
+  return void 0;
+}
+function clearPathEnvCaches() {
+  pathEnvCache.clear();
+  pathEnvByPath.clear();
+  pathEnvBaseDirs.clear();
+}
+async function preloadPathEnvs(envNames, baseDir) {
+  addPathEnvBaseDir(baseDir);
+  for (const name of envNames) {
+    if (!isPathEnvName(name, baseDir)) continue;
+    const resolved = resolvePath(baseDir, name);
+    if (!existsSync(resolved)) continue;
+    try {
+      const { mtimeMs } = statSync(resolved);
+      await importPathEnv(resolved, mtimeMs);
+    } catch {
+    }
+  }
+}
+async function loadEnvsAsync(envNames, globalEnv, baseDir = process.cwd()) {
+  await preloadPathEnvs(envNames, baseDir);
+  return loadEnvs(envNames, globalEnv);
+}
+function loadEnvs(envNames, globalEnv) {
+  const allModules = {};
+  const allGlobals = {};
+  const resolved = resolveEnvNames(envNames);
+  for (const name of resolved) {
+    const factory = envFactories[name] ?? lookupPathEnv(name);
+    if (!factory) continue;
+    const def = factory();
+    for (const [key, value] of Object.entries(def.globals)) {
+      allGlobals[key] = value;
+      globalEnv.bind(key, value);
+    }
+    if (def.modules) {
+      for (const [modName, exports] of Object.entries(def.modules)) {
+        allModules[modName] = { ...allModules[modName], ...exports };
+      }
+    }
+  }
+  return { modules: allModules, globals: allGlobals };
+}
+
 // src/evaluator/config.ts
-import { readFileSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { resolve, dirname, relative, sep } from "path";
 
 // src/session-cache-limits.ts
@@ -414,9 +652,9 @@ function findProjectConfig(startDir) {
   const root = resolve("/");
   while (dir !== root) {
     const pkgPath = resolve(dir, "package.json");
-    if (existsSync(pkgPath)) {
+    if (existsSync2(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
         if (pkg.nudo) {
           const nudo = pkg.nudo;
           setSessionCacheFromProject(nudo.sessionCache);
@@ -435,14 +673,14 @@ function findProjectConfig(startDir) {
 }
 
 // src/evaluator/resolve-npm.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, statSync } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { resolve as resolve2, join, dirname as dirname2 } from "path";
 function findNodeModules(startDir) {
   let dir = resolve2(startDir);
   const root = resolve2("/");
   while (dir !== root) {
     const nmPath = join(dir, "node_modules");
-    if (existsSync2(nmPath)) return nmPath;
+    if (existsSync3(nmPath)) return nmPath;
     const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
@@ -460,11 +698,11 @@ function resolveNpmJsEntry(source, fromDir) {
   if (!nodeModules) return null;
   const pkgDir = join(nodeModules, pkgName);
   const pkgJsonPath = join(pkgDir, "package.json");
-  if (!existsSync2(pkgJsonPath)) return null;
+  if (!existsSync3(pkgJsonPath)) return null;
   const tryFile = (p) => {
     for (const c of [p, `${p}.js`, `${p}.cjs`, `${p}.mjs`, join(p, "index.js"), join(p, "index.cjs")]) {
       try {
-        if (existsSync2(c) && statSync(c).isFile()) return c;
+        if (existsSync3(c) && statSync2(c).isFile()) return c;
       } catch {
       }
     }
@@ -472,7 +710,7 @@ function resolveNpmJsEntry(source, fromDir) {
   };
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -534,13 +772,13 @@ function resolveNpmNudo(source, fromDir) {
   const nodeModules = findNodeModules(fromDir);
   if (!nodeModules) return null;
   const pkgJsonPath = join(nodeModules, pkgName, "package.json");
-  if (!existsSync2(pkgJsonPath)) return null;
+  if (!existsSync3(pkgJsonPath)) return null;
   try {
-    const pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
     const nudoEntry = resolveExportsNudo(pkg.exports, subpath);
     if (nudoEntry) {
       const resolved = resolve2(dirname2(pkgJsonPath), nudoEntry);
-      if (existsSync2(resolved)) return resolved;
+      if (existsSync3(resolved)) return resolved;
     }
   } catch {
   }
@@ -554,6 +792,12 @@ export {
   describeAbsMember,
   builtinProtoMemberNames,
   builtinProtoMember,
+  BoundedLruMap,
+  getPathEnvCacheSizes,
+  clearPathEnvCaches,
+  preloadPathEnvs,
+  loadEnvsAsync,
+  loadEnvs,
   DEFAULT_SESSION_CACHE_LIMITS,
   getSessionCacheLimits,
   setSessionCacheLimits,

package/dist/{interface-BGlP7aIk.d.ts → emit/index.d.ts}

@@ -1,13 +1,9 @@
-import { C as CallRecord } from './call-record-CkyCFkT9.js';
-import { NudoConstraint } from '@nudojs/core';
-
-/**
- * 相对/绝对 specifier → 模块源码。
- * CLI / LSP / vite / check 共用同一扩展名表，避免门禁结果分叉。
- */
-type LoadModule = (spec: string, fromFile: string) => string | undefined;
-/** 默认 loadModule：支持 .js/.mjs/.ts 与 index 入口 */
-declare function defaultLoadModule(spec: string, fromFile: string): string | undefined;
+import { C as CallRecord } from '../call-record-CkyCFkT9.js';
+import { L as LoadModule } from '../what-if-mIo7I5Ii.js';
+export { T as TypeBinding, i as injectBindings, t as typeExprToDirective } from '../what-if-mIo7I5Ii.js';
+import { NudoConstraint, Abs } from '@nudojs/core';
+import { A as AnalysisResult, F as FunctionAnalysis, S as SourceLocation } from '../analyzer-types-CfBrPK9L.js';
+import '@babel/types';
 
 /**
  * `nudo contract` 的打印数据源（design-refine-derivation §11 第 0 步）：
@@ -352,16 +348,260 @@ declare function emitDerivedFromRoot(rootFile: string, opts: {
     refreshExistingOnly?: boolean;
 }): EmitDerivedResult;
 
-type TypeBinding = {
+/**
+ * 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;
-    type: string;
+} | {
+    k: "never";
+} | {
+    k: "unknown";
+};
+type SchemaProjection = {
+    source: string;
+    dialect: SchemaDialect;
+    dropped: string[];
 };
-/** agent 面类型表达式 → `@nudo:as` 文法 */
-declare function typeExprToDirective(expr: string): string;
-declare function injectBindings(source: string, bindings: TypeBinding[]): {
+/** 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;
-    applied: string[];
-    unapplied: 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;
+
+/**
+ * Case facts JSON（`nudo test --json` 序列化）。
+ *
+ * - args / result / throws / combined：formatShape 外延投影（有损）
+ *   入口无约束参数展示为 any；unknown 仅表示推导失败
+ * - intension.abs*：无损 Abs 展示（主线）
+ * - argsAbs / resultAbs：CaseResult 上的无损 Abs（formatAbs）；有则补齐
+ */
+
+type CaseJsonCase = {
+    name: string;
+    /** formatShape 外延投影（有损） */
+    args: string[];
+    result: string;
+    throws: string | null;
+    source: string | null;
+    aggregatedFrom?: number;
+    /** 无损参数 Abs 展示（与 args 对齐；缺失位省略） */
+    argsAbs?: string[];
+    /** 无损结果 Abs 展示 */
+    resultAbs?: string;
+    /** 无损内涵（Abs）；无则省略 */
+    intension?: {
+        display?: string;
+        abs?: string;
+        absMultiline?: string;
+        term?: string;
+        pred?: string;
+        conf?: string;
+    };
+};
+type CaseJsonFunction = {
+    name: string;
+    loc: SourceLocation;
+    entryOnly: boolean;
+    noDeclaration?: boolean;
+    cases: CaseJsonCase[];
+    combined?: string;
+    /** 无损 combined Abs 展示 */
+    combinedAbs?: string;
+};
+type CaseJson = {
+    version: 1;
+    file: string;
+    summary: {
+        functions: number;
+        externalFunctions: number;
+        cases: number;
+        diagnostics: number;
+    };
+    functions: CaseJsonFunction[];
+    externalFunctions?: Array<{
+        name: string;
+        fromModule?: string;
+        cases: CaseJsonCase[];
+    }>;
+    diagnostics: Array<{
+        range: SourceLocation;
+        severity: string;
+        message: string;
+        code?: string;
+        suggestions?: string[];
+        tags?: string[];
+        origin?: {
+            line: number;
+            column: number;
+        };
+    }>;
+};
+declare function serializeCaseJson(result: AnalysisResult, file: string): CaseJson;
+
+/** 单个 Abs → parseCaseArgExpr 可解析回去的表达式文本；不可表达返回 null */
+declare function serializeCaseArg(a: Abs): string | null;
+/**
+ * 组装单行 ` * @nudo:case "name" (a, b)` 指令文本（无尾换行）。
+ * 任一实参不可序列化、或名字含双引号/换行（名字正则 `"([^"]+)"` 承载不了）→ 整体 null。
+ */
+declare function buildCaseDirective(name: string, argsAbs: Abs[]): string | null;
+/**
+ * 从源码剥离所有本模块生成的 @nudo:case 指令（名字以 call@ 开头，整行删除）。
+ * 若所属 JSDoc 块因此只剩空 ` *` 行（无其他 @nudo:* 指令、无文字内容），
+ * 连块首 `/**` 行与块尾行整块删除。绝不碰非 case 指令与普通注释。
+ * 注意：手写但以 call@ 命名的 case 同样会被删——call@ 前缀保留为生成物标记。
+ * removed 返回被删指令名列表（按出现顺序）。
+ */
+declare function stripGeneratedCaseDirectives(source: string): {
+    source: string;
+    removed: string[];
+};
+type EmitSkipReason = "hand-written" | "already-generated" | "entry-only" | "no-serializable-cases" | "no-declaration" | "skipped";
+type EmitResult = {
+    source: string;
+    changed: boolean;
+    written: Array<{
+        fn: string;
+        cases: string[];
+    }>;
+    skipped: Array<{
+        fn: string;
+        reason: EmitSkipReason;
+        detail?: string;
+    }>;
+};
+/**
+ * 把 analysis 中的合成 case（source === "callsite"）固化为源码指令：
+ *
+ * 1. 源码已有任何非 call@ 命名的 case → skip "hand-written"；
+ *    已有 call@ case → skip "already-generated"。
+ * 2. fn.skipped / fn.noDeclaration / fn.entryOnly → 对应 skip。
+ * 3. 逐 case 序列化；个别不可序列化的丢弃并在 skipped 记
+ *    no-serializable-cases（函数整体仍写可序列化子集，全不可序列化才整函数跳过）。
+ * 4. 写入位置：函数声明行正上方——已有 JSDoc 块则插到 `/**` 行后，
+ *    无块则新建三行块。缩进取声明行的 loc.start.column（babel 0 基列）。
+ *    多函数编辑按行号从下往上应用，避免行号漂移。
+ */
+declare function insertGeneratedCaseDirectives(source: string, analysis: AnalysisResult): EmitResult;
+/** 行级 unified diff：`--- a/path` 头 + `@@` hunk + 上下文 3 行；相同返回 "" */
+declare function unifiedDiff(a: string, b: string, path: string): string;
 
-export { typeExprToDirective as A, writeInterfaceDraft as B, type ConstraintSourceExpr as C, type DerivedExport as D, type EmitDerivedResult as E, type InterfaceDraftEntry as I, type LoadModule as L, type RootDeriveOpts as R, type TypeBinding as T, type WriteDraftResult as W, type DerivedParam as a, type DraftEvidence as b, type EmitInterfaceOpts as c, type EmitInterfaceResult as d, type EmitInterfaceSkipReason as e, type InterfaceDraftOpts as f, type InterfaceDraftResult as g, type InterfaceSurfaceEntry as h, type InterfaceSurfaceOpts as i, type RootDeriveResult as j, collectParamBodyAccesses as k, defaultLoadModule as l, deriveFromRoot as m, draftInterface as n, emitDerivedFromRoot as o, emitInterface as p, extractFnConstraintSources as q, formatDerivedSection as r, formatDraftModule as s, formatDraftSummary as t, formatEmitSummary as u, formatInterfaceSurfaceLine as v, injectBindings as w, interfaceSurface as x, isDraftableEntry as y, sidecarDraftPath as z };
+export { type CaseJson, type CaseJsonCase, type CaseJsonFunction, type ConstraintSourceExpr, type DerivedExport, type DerivedParam, type DraftEvidence, type EmitDerivedResult, type EmitInterfaceOpts, type EmitInterfaceResult, type EmitInterfaceSkipReason, type EmitResult, type EmitSkipReason, type InterfaceDraftEntry, type InterfaceDraftOpts, type InterfaceDraftResult, type InterfaceSurfaceEntry, type InterfaceSurfaceOpts, type RootDeriveOpts, type RootDeriveResult, type SchemaDialect, type SchemaNode, type SchemaProjection, type SchemaRefinement, type StandardSchemaIssue, type StandardSchemaModuleProjection, type StandardSchemaResult, type WriteDraftResult, absToSchemaNode, absToSchemaSource, absToStandardSchema, absToStandardSchemaModule, absToTSType, buildCaseDirective, collectParamBodyAccesses, constraintToSchemaNode, deriveFromRoot, draftInterface, emitDerivedFromRoot, emitInterface, extractFnConstraintSources, formatDerivedSection, formatDraftModule, formatDraftSummary, formatEmitSummary, formatInterfaceSurfaceLine, generateDts, generateFunctionDtsLines, generateGuardFunction, generateGuardFunctionFromAbs, insertGeneratedCaseDirectives, interfaceSurface, isDraftableEntry, projectAbsToSchema, schemaNodeToZod, serializeCaseArg, serializeCaseJson, sidecarDraftPath, stripGeneratedCaseDirectives, unifiedDiff, validateSchemaNode, writeInterfaceDraft };