@manifesto-ai/codegen 0.1.0 → 0.1.2

package/README.md

@@ -36,7 +36,7 @@ DomainSchema -> CODEGEN -> Generated Files
 
 | NOT Responsible For | Who Is |
 |--------------------|--------|
-| Define schemas | App (DomainSchema authoring) |
+| Define schemas | SDK / Compiler (DomainSchema authoring) |
 | Runtime validation | Application code using generated Zod schemas |
 | Bundling or compilation | Build tools (tsc, esbuild, etc.) |
 | Schema versioning | `@manifesto-ai/core` |
@@ -162,7 +162,7 @@ Same DomainSchema always produces byte-identical output files. Fields and types
 | Relationship | Package | How |
 |--------------|---------|-----|
 | Depends on | `@manifesto-ai/core` | Reads DomainSchema, TypeDefinition, TypeSpec |
-| Used by | App build scripts | Called during build to generate type-safe code |
+| Used by | Build scripts | Called during build to generate type-safe code |
 
 ---
 

package/dist/index.d.ts

@@ -1,10 +1,114 @@
-export type { Diagnostic, FilePatch, CodegenPlugin, CodegenContext, CodegenOutput, CodegenHelpers, GenerateOptions, GenerateResult, } from "./types.js";
-export { generate } from "./runner.js";
-export { createTsPlugin, createZodPlugin } from "./plugins/index.js";
-export type { TsPluginOptions, TsPluginArtifacts, ZodPluginOptions } from "./plugins/index.js";
-export { validatePath } from "./path-safety.js";
-export type { PathValidationResult } from "./path-safety.js";
-export { stableHash } from "./stable-hash.js";
-export { generateHeader } from "./header.js";
-export type { HeaderOptions } from "./header.js";
-//# sourceMappingURL=index.d.ts.map
+import { DomainSchema } from '@manifesto-ai/core';
+
+type Diagnostic = {
+    readonly level: "warn" | "error";
+    readonly plugin: string;
+    readonly message: string;
+};
+type FilePatch = {
+    readonly op: "set";
+    readonly path: string;
+    readonly content: string;
+} | {
+    readonly op: "delete";
+    readonly path: string;
+};
+interface CodegenHelpers {
+    stableHash(input: unknown): string;
+}
+interface CodegenContext {
+    readonly schema: DomainSchema;
+    readonly sourceId?: string;
+    readonly outDir: string;
+    readonly artifacts: Readonly<Record<string, unknown>>;
+    readonly helpers: CodegenHelpers;
+}
+interface CodegenOutput {
+    readonly patches: readonly FilePatch[];
+    readonly artifacts?: Readonly<Record<string, unknown>>;
+    readonly diagnostics?: readonly Diagnostic[];
+}
+interface CodegenPlugin {
+    readonly name: string;
+    generate(ctx: CodegenContext): CodegenOutput | Promise<CodegenOutput>;
+}
+interface GenerateOptions {
+    readonly schema: DomainSchema;
+    readonly outDir: string;
+    readonly plugins: readonly CodegenPlugin[];
+    readonly sourceId?: string;
+    readonly stamp?: boolean;
+}
+interface GenerateResult {
+    readonly files: ReadonlyArray<{
+        readonly path: string;
+        readonly content: string;
+    }>;
+    readonly artifacts: Readonly<Record<string, unknown>>;
+    readonly diagnostics: readonly Diagnostic[];
+}
+
+/**
+ * Generate typed artifacts from a DomainSchema using plugins.
+ *
+ * This is the sole entry point for codegen. It orchestrates:
+ * - Plugin name uniqueness validation (GEN-2)
+ * - Sequential plugin execution (GEN-3, GEN-7)
+ * - FilePatch composition with collision detection
+ * - Error gating (GEN-5, GEN-8)
+ * - outDir clean + file flush (GEN-1)
+ */
+declare function generate(opts: GenerateOptions): Promise<GenerateResult>;
+
+interface TsPluginOptions {
+    readonly typesFile?: string;
+    readonly actionsFile?: string;
+}
+interface TsPluginArtifacts {
+    readonly typeNames: string[];
+    readonly typeImportPath: string;
+}
+declare function createTsPlugin(options?: TsPluginOptions): CodegenPlugin;
+
+interface ZodPluginOptions {
+    readonly schemasFile?: string;
+}
+declare function createZodPlugin(options?: ZodPluginOptions): CodegenPlugin;
+
+type PathValidationResult = {
+    valid: true;
+    normalized: string;
+} | {
+    valid: false;
+    reason: string;
+};
+/**
+ * Validate and normalize a file path per FP-1, FP-2, GEN-6.
+ *
+ * - MUST be a POSIX relative path
+ * - MUST NOT contain `..`, absolute prefixes, drive letters, or null bytes
+ * - Normalizes backslashes, multiple slashes, and leading `./`
+ */
+declare function validatePath(path: string): PathValidationResult;
+
+/**
+ * Deterministic hash function (DET-1).
+ * Same input always produces the same output.
+ * Uses Core's canonical form (sorted keys, no undefined) + SHA-256.
+ */
+declare function stableHash(input: unknown): string;
+
+interface HeaderOptions {
+    readonly sourceId?: string;
+    readonly schemaHash: string;
+    readonly stamp?: boolean;
+}
+/**
+ * Generate the @generated file header (DET-2, DET-3, DET-4).
+ *
+ * Default mode: no timestamp (deterministic).
+ * With stamp=true: appends ISO 8601 timestamp line.
+ */
+declare function generateHeader(options: HeaderOptions): string;
+
+export { type CodegenContext, type CodegenHelpers, type CodegenOutput, type CodegenPlugin, type Diagnostic, type FilePatch, type GenerateOptions, type GenerateResult, type HeaderOptions, type PathValidationResult, type TsPluginArtifacts, type TsPluginOptions, type ZodPluginOptions, createTsPlugin, createZodPlugin, generate, generateHeader, stableHash, validatePath };

package/dist/index.js

@@ -1,14 +1,544 @@
-// @manifesto-ai/codegen
-// Plugin-based code generation from DomainSchema
-//
-// See: docs/SPEC-v0.1.1.md for specification
-// See: docs/ADR-CODEGEN-001.md for architecture decisions
-// Runner
-export { generate } from "./runner.js";
-// Plugins
-export { createTsPlugin, createZodPlugin } from "./plugins/index.js";
-// Utilities (for custom plugin authors)
-export { validatePath } from "./path-safety.js";
-export { stableHash } from "./stable-hash.js";
-export { generateHeader } from "./header.js";
+// src/runner.ts
+import * as fs from "fs/promises";
+import * as nodePath from "path";
+
+// src/virtual-fs.ts
+var VirtualFS = class {
+  files = /* @__PURE__ */ new Map();
+  deleted = /* @__PURE__ */ new Set();
+  /**
+   * Apply a FilePatch to the virtual FS.
+   * Returns a Diagnostic if a collision/warning condition is detected.
+   */
+  applyPatch(patch, pluginName) {
+    if (patch.op === "set") {
+      return this.applySet(patch.path, patch.content, pluginName);
+    }
+    return this.applyDelete(patch.path, pluginName);
+  }
+  applySet(path, content, pluginName) {
+    const existing = this.files.get(path);
+    if (existing) {
+      const samePlugin = existing.source === pluginName;
+      return {
+        level: "error",
+        plugin: pluginName,
+        message: samePlugin ? `Duplicate set on "${path}" within plugin "${pluginName}"` : `File "${path}" already set by plugin "${existing.source}", cannot be set again by "${pluginName}"`
+      };
+    }
+    this.deleted.delete(path);
+    this.files.set(path, { content, source: pluginName });
+    return void 0;
+  }
+  applyDelete(path, pluginName) {
+    const existing = this.files.get(path);
+    if (!existing && !this.deleted.has(path)) {
+      return {
+        level: "warn",
+        plugin: pluginName,
+        message: `Delete on nonexistent path "${path}"`
+      };
+    }
+    if (existing) {
+      this.files.delete(path);
+      this.deleted.add(path);
+      return {
+        level: "warn",
+        plugin: pluginName,
+        message: `File "${path}" set by plugin "${existing.source}" is being deleted by "${pluginName}". Prior work is voided.`
+      };
+    }
+    this.deleted.add(path);
+    return void 0;
+  }
+  /**
+   * Get all files in deterministic (lexicographic) order (DET-5).
+   */
+  getFiles() {
+    const entries = Array.from(this.files.entries());
+    entries.sort(([a], [b]) => a.localeCompare(b));
+    return entries.map(([path, { content }]) => ({ path, content }));
+  }
+  has(path) {
+    return this.files.has(path);
+  }
+};
+
+// src/path-safety.ts
+function validatePath(path) {
+  if (!path) {
+    return { valid: false, reason: "Path must not be empty" };
+  }
+  if (path.includes("\0")) {
+    return { valid: false, reason: "Path must not contain null bytes" };
+  }
+  let normalized = path.replace(/\\/g, "/");
+  if (/^[a-zA-Z]:/.test(normalized)) {
+    return { valid: false, reason: "Path must not contain drive letters" };
+  }
+  if (normalized.startsWith("/")) {
+    return { valid: false, reason: "Path must be relative, not absolute" };
+  }
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  if (normalized.endsWith("/") && normalized.length > 1) {
+    normalized = normalized.slice(0, -1);
+  }
+  const segments = normalized.split("/");
+  for (const segment of segments) {
+    if (segment === "..") {
+      return { valid: false, reason: "Path must not contain '..' traversal" };
+    }
+  }
+  if (!normalized) {
+    return { valid: false, reason: "Path resolves to empty after normalization" };
+  }
+  return { valid: true, normalized };
+}
+
+// src/stable-hash.ts
+import { toCanonical, sha256Sync } from "@manifesto-ai/core";
+function stableHash(input) {
+  const canonical = toCanonical(input);
+  return sha256Sync(canonical);
+}
+
+// src/header.ts
+function generateHeader(options) {
+  const source = options.sourceId ?? "unknown";
+  const lines = [
+    "// @generated by @manifesto-ai/codegen \u2014 DO NOT EDIT",
+    `// Source: ${source} | Schema hash: ${options.schemaHash}`
+  ];
+  if (options.stamp) {
+    lines.push(`// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/runner.ts
+async function generate(opts) {
+  const diagnostics = [];
+  const allArtifacts = {};
+  const vfs = new VirtualFS();
+  const nameError = validatePluginNames(opts.plugins);
+  if (nameError) {
+    return {
+      files: [],
+      artifacts: {},
+      diagnostics: [nameError]
+    };
+  }
+  for (const plugin of opts.plugins) {
+    const ctx = {
+      schema: opts.schema,
+      sourceId: opts.sourceId,
+      outDir: opts.outDir,
+      artifacts: Object.freeze({ ...allArtifacts }),
+      // PLG-9: frozen snapshot
+      helpers: { stableHash }
+    };
+    let output;
+    try {
+      output = await plugin.generate(ctx);
+    } catch (err) {
+      diagnostics.push({
+        level: "error",
+        plugin: plugin.name,
+        message: `Plugin threw: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    if (output.diagnostics) {
+      diagnostics.push(...output.diagnostics);
+    }
+    for (const patch of output.patches) {
+      const validation = validatePath(patch.path);
+      if (!validation.valid) {
+        diagnostics.push({
+          level: "error",
+          plugin: plugin.name,
+          message: `Invalid path "${patch.path}": ${validation.reason}`
+        });
+        continue;
+      }
+      const normalizedPatch = patch.op === "set" ? { op: "set", path: validation.normalized, content: patch.content } : { op: "delete", path: validation.normalized };
+      const collision = vfs.applyPatch(normalizedPatch, plugin.name);
+      if (collision) {
+        diagnostics.push(collision);
+      }
+    }
+    if (output.artifacts) {
+      allArtifacts[plugin.name] = output.artifacts;
+    }
+  }
+  const files = vfs.getFiles();
+  const hasErrors = diagnostics.some((d) => d.level === "error");
+  if (hasErrors) {
+    return { files, artifacts: allArtifacts, diagnostics };
+  }
+  await fs.rm(opts.outDir, { recursive: true, force: true });
+  const header = generateHeader({
+    sourceId: opts.sourceId,
+    schemaHash: opts.schema.hash,
+    stamp: opts.stamp
+  });
+  for (const file of files) {
+    const absPath = nodePath.join(opts.outDir, ...file.path.split("/"));
+    const dir = nodePath.dirname(absPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(absPath, header + file.content, "utf-8");
+  }
+  return { files, artifacts: allArtifacts, diagnostics };
+}
+function validatePluginNames(plugins) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    if (!plugin.name) {
+      return {
+        level: "error",
+        plugin: "",
+        message: "Plugin name must not be empty (PLG-1)"
+      };
+    }
+    if (seen.has(plugin.name)) {
+      return {
+        level: "error",
+        plugin: plugin.name,
+        message: `Duplicate plugin name "${plugin.name}" (GEN-2)`
+      };
+    }
+    seen.add(plugin.name);
+  }
+  return void 0;
+}
+
+// src/plugins/ts-plugin.ts
+var PLUGIN_NAME = "codegen-plugin-ts";
+function createTsPlugin(options) {
+  const typesFile = options?.typesFile ?? "types.ts";
+  const actionsFile = options?.actionsFile ?? "actions.ts";
+  return {
+    name: PLUGIN_NAME,
+    generate(ctx) {
+      const diagnostics = [];
+      const typeNames = [];
+      const sortedTypeNames = Object.keys(ctx.schema.types).sort();
+      const typeDecls = [];
+      for (const name of sortedTypeNames) {
+        const spec = ctx.schema.types[name];
+        typeNames.push(name);
+        typeDecls.push(renderNamedType(name, spec, diagnostics));
+      }
+      const typesContent = typeDecls.join("\n\n") + "\n";
+      const sortedActionNames = Object.keys(ctx.schema.actions).sort();
+      const actionDecls = [];
+      for (const actionName of sortedActionNames) {
+        const spec = ctx.schema.actions[actionName];
+        if (spec.input) {
+          const typeName = pascalCase(actionName) + "Input";
+          actionDecls.push(renderActionInputType(typeName, spec, diagnostics));
+        }
+      }
+      const patches = [
+        { op: "set", path: typesFile, content: typesContent }
+      ];
+      if (actionDecls.length > 0) {
+        const actionsContent = actionDecls.join("\n\n") + "\n";
+        patches.push({ op: "set", path: actionsFile, content: actionsContent });
+      }
+      const artifacts = {
+        typeNames,
+        typeImportPath: `./${typesFile.replace(/\.ts$/, "")}`
+      };
+      return { patches, artifacts, diagnostics };
+    }
+  };
+}
+function renderNamedType(name, spec, diagnostics) {
+  const def = spec.definition;
+  if (def.kind === "object") {
+    return renderInterface(name, def.fields, diagnostics);
+  }
+  const tsType = mapTypeDefinition(def, diagnostics);
+  return `export type ${name} = ${tsType};`;
+}
+function renderInterface(name, fields, diagnostics) {
+  const sortedFields = Object.keys(fields).sort();
+  const lines = [];
+  for (const fieldName of sortedFields) {
+    const field = fields[fieldName];
+    const tsType = mapTypeDefinition(field.type, diagnostics);
+    const opt = field.optional ? "?" : "";
+    lines.push(`  ${fieldName}${opt}: ${tsType};`);
+  }
+  return `export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function mapTypeDefinition(def, diagnostics) {
+  switch (def.kind) {
+    case "primitive":
+      return mapPrimitive(def.type);
+    case "literal":
+      return renderLiteral(def.value);
+    case "array":
+      return `${wrapComplex(mapTypeDefinition(def.element, diagnostics), def.element)}[]`;
+    case "record":
+      return `Record<${mapTypeDefinition(def.key, diagnostics)}, ${mapTypeDefinition(def.value, diagnostics)}>`;
+    case "object": {
+      const sortedFields = Object.keys(def.fields).sort();
+      const parts = [];
+      for (const fieldName of sortedFields) {
+        const field = def.fields[fieldName];
+        const tsType = mapTypeDefinition(field.type, diagnostics);
+        const opt = field.optional ? "?" : "";
+        parts.push(`${fieldName}${opt}: ${tsType}`);
+      }
+      return `{ ${parts.join("; ")} }`;
+    }
+    case "union":
+      return def.types.map((t) => mapTypeDefinition(t, diagnostics)).join(" | ");
+    case "ref":
+      return def.name;
+    default: {
+      diagnostics.push({
+        level: "warn",
+        plugin: PLUGIN_NAME,
+        message: `Unknown TypeDefinition kind: "${def.kind}". Emitting "unknown".`
+      });
+      return "unknown";
+    }
+  }
+}
+function mapPrimitive(type) {
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return "unknown";
+  }
+}
+function renderLiteral(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function wrapComplex(tsType, def) {
+  if (def.kind === "union") {
+    return `(${tsType})`;
+  }
+  return tsType;
+}
+function renderActionInputType(typeName, spec, diagnostics) {
+  if (!spec.input) {
+    return "";
+  }
+  const tsType = mapFieldSpec(spec.input, diagnostics);
+  return `export type ${typeName} = ${tsType};`;
+}
+function mapFieldSpec(spec, diagnostics) {
+  const baseType = mapFieldType(spec.type, spec, diagnostics);
+  if (!spec.required && baseType !== "unknown") {
+    return `${baseType} | null`;
+  }
+  return baseType;
+}
+function mapFieldType(type, spec, diagnostics) {
+  if (typeof type === "object" && "enum" in type) {
+    return type.enum.map((v) => renderLiteral(v)).join(" | ");
+  }
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object": {
+      if (spec.fields) {
+        const sortedFields = Object.keys(spec.fields).sort();
+        const parts = [];
+        for (const name of sortedFields) {
+          const field = spec.fields[name];
+          const fieldType = mapFieldSpec(field, diagnostics);
+          const opt = field.required ? "" : "?";
+          parts.push(`${name}${opt}: ${fieldType}`);
+        }
+        return `{ ${parts.join("; ")} }`;
+      }
+      diagnostics.push({
+        level: "warn",
+        plugin: PLUGIN_NAME,
+        message: "Object field without fields spec, degrading to Record<string, unknown>"
+      });
+      return "Record<string, unknown>";
+    }
+    case "array": {
+      if (spec.items) {
+        return `${mapFieldSpec(spec.items, diagnostics)}[]`;
+      }
+      diagnostics.push({
+        level: "warn",
+        plugin: PLUGIN_NAME,
+        message: "Array field without items spec, degrading to unknown[]"
+      });
+      return "unknown[]";
+    }
+    default:
+      return "unknown";
+  }
+}
+function pascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+
+// src/plugins/zod-plugin.ts
+var PLUGIN_NAME2 = "codegen-plugin-zod";
+var TS_PLUGIN_NAME = "codegen-plugin-ts";
+function createZodPlugin(options) {
+  const schemasFile = options?.schemasFile ?? "base.ts";
+  return {
+    name: PLUGIN_NAME2,
+    generate(ctx) {
+      const diagnostics = [];
+      const tsArtifacts = ctx.artifacts[TS_PLUGIN_NAME];
+      const sortedTypeNames = Object.keys(ctx.schema.types).sort();
+      const schemaDecls = [];
+      const allTypeNames = new Set(sortedTypeNames);
+      for (const name of sortedTypeNames) {
+        const spec = ctx.schema.types[name];
+        schemaDecls.push(renderNamedSchema(name, spec, allTypeNames, tsArtifacts, diagnostics));
+      }
+      const imports = ['import { z } from "zod";'];
+      if (tsArtifacts && tsArtifacts.typeNames.length > 0) {
+        const typeImports = sortedTypeNames.filter((n) => tsArtifacts.typeNames.includes(n)).join(", ");
+        if (typeImports) {
+          imports.push(`import type { ${typeImports} } from "${tsArtifacts.typeImportPath}";`);
+        }
+      }
+      const content = imports.join("\n") + "\n\n" + schemaDecls.join("\n\n") + "\n";
+      return {
+        patches: [{ op: "set", path: schemasFile, content }],
+        diagnostics
+      };
+    }
+  };
+}
+function renderNamedSchema(name, spec, allTypeNames, tsArtifacts, diagnostics) {
+  const schemaName = `${name}Schema`;
+  const zodExpr = mapTypeDefinition2(spec.definition, allTypeNames, diagnostics);
+  const hasTypeAnnotation = tsArtifacts && tsArtifacts.typeNames.includes(name);
+  const annotation = hasTypeAnnotation ? `: z.ZodType<${name}>` : "";
+  return `export const ${schemaName}${annotation} = ${zodExpr};`;
+}
+function mapTypeDefinition2(def, allTypeNames, diagnostics) {
+  switch (def.kind) {
+    case "primitive":
+      return mapPrimitiveZod(def.type);
+    case "literal":
+      return `z.literal(${renderLiteralValue(def.value)})`;
+    case "array":
+      return `z.array(${mapTypeDefinition2(def.element, allTypeNames, diagnostics)})`;
+    case "record":
+      return handleRecord(def, allTypeNames, diagnostics);
+    case "object":
+      return renderZodObject(def.fields, allTypeNames, diagnostics);
+    case "union":
+      return handleUnion(def.types, allTypeNames, diagnostics);
+    case "ref":
+      return `z.lazy(() => ${def.name}Schema)`;
+    default: {
+      diagnostics.push({
+        level: "warn",
+        plugin: PLUGIN_NAME2,
+        message: `Unknown TypeDefinition kind: "${def.kind}". Emitting "z.unknown()".`
+      });
+      return "z.unknown()";
+    }
+  }
+}
+function mapPrimitiveZod(type) {
+  switch (type) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "null":
+      return "z.null()";
+    default:
+      return "z.unknown()";
+  }
+}
+function renderLiteralValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  return String(value);
+}
+function handleRecord(def, allTypeNames, diagnostics) {
+  const valueSchema = mapTypeDefinition2(def.value, allTypeNames, diagnostics);
+  if (def.key.kind !== "primitive" || def.key.type !== "string") {
+    diagnostics.push({
+      level: "warn",
+      plugin: PLUGIN_NAME2,
+      message: `Record key type is not string (got ${JSON.stringify(def.key)}). Degrading to z.record(z.string(), ...).`
+    });
+    return `z.record(z.string(), ${valueSchema})`;
+  }
+  return `z.record(z.string(), ${valueSchema})`;
+}
+function renderZodObject(fields, allTypeNames, diagnostics) {
+  const sortedFields = Object.keys(fields).sort();
+  const parts = [];
+  for (const fieldName of sortedFields) {
+    const field = fields[fieldName];
+    let zodType = mapTypeDefinition2(field.type, allTypeNames, diagnostics);
+    if (field.optional) {
+      zodType += ".optional()";
+    }
+    parts.push(`  ${fieldName}: ${zodType},`);
+  }
+  return `z.object({
+${parts.join("\n")}
+})`;
+}
+function handleUnion(types, allTypeNames, diagnostics) {
+  if (types.length === 2) {
+    const nullIdx = types.findIndex(
+      (t) => t.kind === "primitive" && t.type === "null"
+    );
+    if (nullIdx !== -1) {
+      const otherIdx = nullIdx === 0 ? 1 : 0;
+      const otherSchema = mapTypeDefinition2(types[otherIdx], allTypeNames, diagnostics);
+      return `z.nullable(${otherSchema})`;
+    }
+  }
+  const schemas = types.map((t) => mapTypeDefinition2(t, allTypeNames, diagnostics));
+  return `z.union([${schemas.join(", ")}])`;
+}
+export {
+  createTsPlugin,
+  createZodPlugin,
+  generate,
+  generateHeader,
+  stableHash,
+  validatePath
+};
 //# sourceMappingURL=index.js.map