@schemashift/zod-valibot 0.7.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/transformer.ts","../src/mappings.ts","../src/handler.ts"],"sourcesContent":["export { createZodToValibotHandler } from './handler.js';\nexport {\n  FACTORY_MAPPINGS,\n  MODIFIER_METHODS,\n  NUMBER_VALIDATION_MAPPINGS,\n  OBJECT_METHODS,\n  VALIDATION_MAPPINGS,\n} from './mappings.js';\nexport { ZodToValibotTransformer } from './transformer.js';\n","import {\n  isInsideStringLiteral,\n  type MethodCallInfo,\n  parseCallChain,\n  type TransformError,\n  type TransformResult,\n} from '@schemashift/core';\nimport { type CallExpression, Node, type SourceFile } from 'ts-morph';\nimport {\n  FACTORY_MAPPINGS,\n  MODIFIER_METHODS,\n  NUMBER_VALIDATION_MAPPINGS,\n  OBJECT_METHODS,\n  VALIDATION_MAPPINGS,\n} from './mappings.js';\n\n/**\n * Zod to Valibot transformer.\n *\n * Converts Zod's fluent method chain API to Valibot's pipe-based API.\n *\n * Zod:     z.string().email().min(5).max(100)\n * Valibot: v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))\n *\n * Zod:     z.string().optional()\n * Valibot: v.optional(v.string())\n *\n * Zod:     z.object({ name: z.string() }).partial()\n * Valibot: v.partial(v.object({ name: v.string() }))\n */\nexport class ZodToValibotTransformer {\n  private errors: TransformError[] = [];\n  private warnings: string[] = [];\n\n  transform(sourceFile: SourceFile): TransformResult {\n    this.errors = [];\n    this.warnings = [];\n\n    const filePath = sourceFile.getFilePath();\n    const originalCode = sourceFile.getFullText();\n\n    try {\n      this.updateImports(sourceFile);\n      this.transformTypeHelpers(sourceFile);\n      this.transformSchemaExpressions(sourceFile);\n\n      return {\n        success: this.errors.length === 0,\n        filePath,\n        originalCode,\n        transformedCode: sourceFile.getFullText(),\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    } catch (error) {\n      this.errors.push({\n        message: error instanceof Error ? error.message : 'Unknown error',\n      });\n      return {\n        success: false,\n        filePath,\n        originalCode,\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    }\n  }\n\n  private updateImports(sourceFile: SourceFile): void {\n    const zodImports = sourceFile\n      .getImportDeclarations()\n      .filter((imp) => imp.getModuleSpecifierValue() === 'zod');\n\n    for (const imp of zodImports) {\n      imp.setModuleSpecifier('valibot');\n\n      const namespaceImport = imp.getNamespaceImport();\n      const defaultImport = imp.getDefaultImport();\n      const namedImports = imp.getNamedImports();\n\n      if (namespaceImport) imp.removeNamespaceImport();\n      if (defaultImport) imp.removeDefaultImport();\n      if (namedImports.length > 0) imp.removeNamedImports();\n\n      imp.setNamespaceImport('v');\n    }\n  }\n\n  private transformTypeHelpers(sourceFile: SourceFile): void {\n    const fullText = sourceFile.getFullText();\n    let newText = fullText;\n    newText = newText.replace(/\\bz\\.infer</g, 'v.InferOutput<');\n    newText = newText.replace(/\\bz\\.input</g, 'v.InferInput<');\n    newText = newText.replace(/\\bz\\.output</g, 'v.InferOutput<');\n    if (newText !== fullText) {\n      sourceFile.replaceWithText(newText);\n    }\n  }\n\n  private transformSchemaExpressions(sourceFile: SourceFile): void {\n    const nodesToTransform: CallExpression[] = [];\n\n    sourceFile.forEachDescendant((node) => {\n      if (Node.isCallExpression(node)) {\n        if (isInsideStringLiteral(node)) return;\n\n        const text = node.getText();\n        if (text.startsWith('z.')) {\n          nodesToTransform.push(node);\n        }\n      }\n    });\n\n    const outermost = this.filterOutermostNodes(nodesToTransform);\n    outermost.sort((a, b) => b.getStart() - a.getStart());\n\n    for (const node of outermost) {\n      this.transformCallChain(node);\n    }\n  }\n\n  private filterOutermostNodes(nodes: CallExpression[]): CallExpression[] {\n    const result: CallExpression[] = [];\n    for (const node of nodes) {\n      let isChild = false;\n      for (const other of nodes) {\n        if (other === node) continue;\n        if (other.getStart() <= node.getStart() && other.getEnd() >= node.getEnd()) {\n          isChild = true;\n          break;\n        }\n      }\n      if (!isChild) result.push(node);\n    }\n    return result;\n  }\n\n  private transformCallChain(node: CallExpression): void {\n    const chain = parseCallChain(node);\n\n    if (!chain) {\n      this.transformCallChainFallback(node);\n      return;\n    }\n\n    if (chain.base !== 'z') return;\n\n    const filePath = node.getSourceFile().getFilePath();\n    const lineNumber = node.getStartLineNumber();\n\n    // Map the factory method\n    const factoryMapping = FACTORY_MAPPINGS[chain.factoryMethod];\n    if (!factoryMapping) {\n      this.warnings.push(\n        `${filePath}:${lineNumber}: Unknown Zod factory z.${chain.factoryMethod}() — kept as-is`,\n      );\n      return;\n    }\n\n    // Determine the factory context for contextual mappings (string vs number vs array)\n    const factoryType = chain.factoryMethod;\n\n    // Categorize methods\n    const pipeValidators: string[] = [];\n    const modifiers: Array<{ name: string; args: string[] }> = [];\n    const objectMethods: Array<{ name: string; args: string[] }> = [];\n\n    for (const method of chain.methods) {\n      const result = this.categorizeMethod(method, factoryType, filePath, lineNumber);\n      if (result.type === 'pipe') {\n        pipeValidators.push(result.code);\n      } else if (result.type === 'modifier') {\n        modifiers.push({ name: result.name, args: result.args });\n      } else if (result.type === 'object') {\n        objectMethods.push({ name: result.name, args: result.args });\n      }\n      // 'skip' type means the method is removed\n    }\n\n    // Build the Valibot expression\n    let result: string;\n\n    // Start with the factory call\n    const factoryCall = `${factoryMapping}(${chain.factoryArgs.join(', ')})`;\n\n    // If there are pipe validators, wrap in v.pipe()\n    if (pipeValidators.length > 0) {\n      result = `v.pipe(${factoryCall}, ${pipeValidators.join(', ')})`;\n    } else {\n      result = factoryCall;\n    }\n\n    // Apply object methods (wrapping)\n    for (const objMethod of objectMethods) {\n      result = this.applyObjectMethod(objMethod.name, objMethod.args, result, filePath, lineNumber);\n    }\n\n    // Apply modifiers (wrapping from inside out)\n    for (const modifier of modifiers) {\n      result = this.applyModifier(modifier.name, modifier.args, result, filePath, lineNumber);\n    }\n\n    // Post-process: transform any remaining nested z. references in the result\n    result = this.transformNestedZodReferences(result);\n\n    node.replaceWithText(result);\n  }\n\n  private transformNestedZodReferences(text: string): string {\n    // Replace z.factoryName( with v.factoryName( for all known factories\n    let result = text;\n    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {\n      const regex = new RegExp(`\\\\bz\\\\.${zodName}\\\\(`, 'g');\n      result = result.replace(regex, `${valibotName}(`);\n    }\n    return result;\n  }\n\n  private categorizeMethod(\n    method: MethodCallInfo,\n    factoryType: string,\n    filePath: string,\n    lineNumber: number,\n  ):\n    | { type: 'pipe'; code: string }\n    | { type: 'modifier'; name: string; args: string[] }\n    | { type: 'object'; name: string; args: string[] }\n    | { type: 'skip' } {\n    const { name, args } = method;\n\n    // Check if it's a modifier (wrapping)\n    if (MODIFIER_METHODS.has(name)) {\n      return { type: 'modifier', name, args };\n    }\n\n    // Check if it's an object method\n    if (OBJECT_METHODS.has(name)) {\n      return { type: 'object', name, args };\n    }\n\n    // Check number-specific validations\n    if (\n      (factoryType === 'number' || factoryType === 'bigint') &&\n      NUMBER_VALIDATION_MAPPINGS[name]\n    ) {\n      const mapping = NUMBER_VALIDATION_MAPPINGS[name];\n      if (!mapping) return { type: 'skip' as const };\n      const mappedArgs = mapping.args(args);\n      return { type: 'pipe', code: `${mapping.name}(${mappedArgs.join(', ')})` };\n    }\n\n    // Check string-specific min/max -> minLength/maxLength\n    if (factoryType === 'string' || factoryType === 'array') {\n      if (name === 'min') {\n        const vName = factoryType === 'string' ? 'v.minLength' : 'v.minLength';\n        return { type: 'pipe', code: `${vName}(${args.join(', ')})` };\n      }\n      if (name === 'max') {\n        const vName = factoryType === 'string' ? 'v.maxLength' : 'v.maxLength';\n        return { type: 'pipe', code: `${vName}(${args.join(', ')})` };\n      }\n    }\n\n    // Check general validation mappings\n    const validationMapping = VALIDATION_MAPPINGS[name];\n    if (validationMapping === null) {\n      // Should be handled by modifier/object checks above, but just in case\n      return { type: 'skip' };\n    }\n    if (validationMapping) {\n      return { type: 'pipe', code: `${validationMapping}(${args.join(', ')})` };\n    }\n\n    // Unknown method\n    this.warnings.push(\n      `${filePath}:${lineNumber}: Unknown Zod method .${name}() — kept as-is in pipe`,\n    );\n    return { type: 'pipe', code: `/* TODO: .${name}(${args.join(', ')}) */` };\n  }\n\n  private applyModifier(\n    name: string,\n    args: string[],\n    inner: string,\n    filePath: string,\n    lineNumber: number,\n  ): string {\n    switch (name) {\n      case 'optional':\n        return `v.optional(${inner})`;\n      case 'nullable':\n        return `v.nullable(${inner})`;\n      case 'nullish':\n        return `v.nullish(${inner})`;\n      case 'default':\n        return `v.optional(${inner}, ${args.join(', ')})`;\n      case 'catch':\n        return `v.fallback(${inner}, ${args.join(', ')})`;\n      case 'readonly':\n        return `v.readonly(${inner})`;\n      case 'transform':\n        return `v.pipe(${inner}, v.transform(${args.join(', ')}))`;\n      case 'refine':\n        if (args.length >= 2) {\n          return `v.pipe(${inner}, v.check(${args[0]}, ${args.slice(1).join(', ')}))`;\n        }\n        return `v.pipe(${inner}, v.check(${args.join(', ')}))`;\n      case 'superRefine':\n        this.warnings.push(\n          `${filePath}:${lineNumber}: .superRefine() requires manual conversion to Valibot custom validation`,\n        );\n        return `v.pipe(${inner}, /* TODO: superRefine -> custom validation */ v.check(${args.join(', ')}))`;\n      case 'brand':\n        return `v.pipe(${inner}, v.brand(${args.join(', ')}))`;\n      case 'describe':\n        // Valibot doesn't have describe, skip it\n        return inner;\n      case 'pipe':\n        return `v.pipe(${inner}, ${args.join(', ')})`;\n      default:\n        return inner;\n    }\n  }\n\n  private applyObjectMethod(\n    name: string,\n    args: string[],\n    inner: string,\n    filePath: string,\n    lineNumber: number,\n  ): string {\n    switch (name) {\n      case 'partial':\n        return `v.partial(${inner})`;\n      case 'required':\n        return `v.required(${inner})`;\n      case 'pick':\n        return `v.pick(${inner}, ${args.join(', ')})`;\n      case 'omit':\n        return `v.omit(${inner}, ${args.join(', ')})`;\n      case 'extend':\n      case 'merge':\n        return `v.merge([${inner}, ${args.join(', ')}])`;\n      case 'passthrough':\n        this.warnings.push(\n          `${filePath}:${lineNumber}: .passthrough() — Valibot objects are loose by default, no action needed`,\n        );\n        return inner;\n      case 'strict':\n        return `v.strict(${inner})`;\n      case 'strip':\n        return inner; // Valibot strips unknown by default when using v.object\n      case 'catchall':\n        this.warnings.push(\n          `${filePath}:${lineNumber}: .catchall() requires manual conversion to Valibot record or custom validation`,\n        );\n        return inner;\n      case 'keyof':\n        this.warnings.push(\n          `${filePath}:${lineNumber}: .keyof() requires manual conversion to v.picklist(Object.keys(...))`,\n        );\n        return inner;\n      default:\n        return inner;\n    }\n  }\n\n  private transformCallChainFallback(node: CallExpression): void {\n    const text = node.getText();\n    const filePath = node.getSourceFile().getFilePath();\n    const lineNumber = node.getStartLineNumber();\n\n    // Simple regex-based fallback for chains we can't parse\n    let transformed = text;\n\n    // Replace z. with v.\n    transformed = transformed.replace(/^z\\./, 'v.');\n\n    // Basic type mappings\n    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {\n      const regex = new RegExp(`\\\\bv\\\\.${zodName}\\\\(`, 'g');\n      transformed = transformed.replace(regex, `${valibotName}(`);\n    }\n\n    this.warnings.push(\n      `${filePath}:${lineNumber}: Complex Zod expression used fallback conversion — manual review recommended`,\n    );\n\n    node.replaceWithText(transformed);\n  }\n}\n","/**\n * Zod -> Valibot method name mappings.\n *\n * Valibot uses a pipe-based API: v.pipe(v.string(), v.email(), v.minLength(5))\n * instead of Zod's fluent chain: z.string().email().min(5)\n *\n * Factory methods map directly. Validation methods become pipe arguments.\n */\n\n/** Zod factory -> Valibot factory */\nexport const FACTORY_MAPPINGS: Record<string, string> = {\n  string: 'v.string',\n  number: 'v.number',\n  boolean: 'v.boolean',\n  date: 'v.date',\n  bigint: 'v.bigint',\n  symbol: 'v.symbol',\n  undefined: 'v.undefined_',\n  null: 'v.null_',\n  void: 'v.void_',\n  any: 'v.any',\n  unknown: 'v.unknown',\n  never: 'v.never',\n  nan: 'v.nan',\n  literal: 'v.literal',\n  enum: 'v.picklist',\n  nativeEnum: 'v.enum_',\n  array: 'v.array',\n  object: 'v.object',\n  record: 'v.record',\n  tuple: 'v.tuple',\n  union: 'v.union',\n  discriminatedUnion: 'v.variant',\n  intersection: 'v.intersect',\n  lazy: 'v.lazy',\n  promise: 'v.promise',\n  instanceof: 'v.instance',\n};\n\n/** Zod chain methods -> Valibot pipe validators */\nexport const VALIDATION_MAPPINGS: Record<string, string | null> = {\n  // String validations\n  email: 'v.email',\n  url: 'v.url',\n  uuid: 'v.uuid',\n  cuid: 'v.cuid2',\n  cuid2: 'v.cuid2',\n  ulid: 'v.ulid',\n  regex: 'v.regex',\n  ip: 'v.ip',\n  datetime: 'v.isoDateTime',\n  date: 'v.isoDate',\n  time: 'v.isoTime',\n  emoji: 'v.emoji',\n  includes: 'v.includes',\n  startsWith: 'v.startsWith',\n  endsWith: 'v.endsWith',\n  trim: 'v.trim',\n  toLowerCase: 'v.toLowerCase',\n  toUpperCase: 'v.toUpperCase',\n\n  // Shared validations (string/number/array/date)\n  min: 'v.minLength', // Will be context-sensitive\n  max: 'v.maxLength', // Will be context-sensitive\n  length: 'v.length',\n\n  // Number validations\n  gt: 'v.minValue',\n  gte: 'v.minValue',\n  lt: 'v.maxValue',\n  lte: 'v.maxValue',\n  int: 'v.integer',\n  positive: 'v.minValue',\n  negative: 'v.maxValue',\n  nonnegative: 'v.minValue',\n  nonpositive: 'v.maxValue',\n  multipleOf: 'v.multipleOf',\n  finite: 'v.finite',\n  safe: 'v.safeInteger',\n\n  // Array validations\n  nonempty: 'v.nonEmpty',\n\n  // Schema modifiers (not pipe validators)\n  optional: null, // Handled specially\n  nullable: null, // Handled specially\n  nullish: null, // Handled specially\n  default: null, // Handled specially\n  catch: null, // Handled specially\n  transform: null, // Handled specially\n  refine: null, // Handled specially\n  superRefine: null, // Handled specially\n  brand: null, // Handled specially\n  readonly: null, // Handled specially\n  pipe: null, // Handled specially\n  describe: null, // Handled specially\n\n  // Object methods\n  partial: null, // Handled specially\n  required: null, // Handled specially\n  pick: null, // Handled specially\n  omit: null, // Handled specially\n  extend: null, // Handled specially\n  merge: null, // Handled specially\n  passthrough: null, // Handled specially\n  strict: null, // Handled specially\n  strip: null, // Handled specially\n  catchall: null, // Handled specially\n  keyof: null, // Handled specially\n\n  // Array methods\n  element: null, // Part of factory\n};\n\n/** Zod number methods that need specific arg mapping to Valibot */\nexport const NUMBER_VALIDATION_MAPPINGS: Record<\n  string,\n  { name: string; args: (args: string[]) => string[] }\n> = {\n  min: { name: 'v.minValue', args: (a) => a },\n  max: { name: 'v.maxValue', args: (a) => a },\n  gt: { name: 'v.minValue', args: (a) => (a.length > 0 ? [String(Number(a[0]) + 1)] : a) },\n  lt: { name: 'v.maxValue', args: (a) => (a.length > 0 ? [String(Number(a[0]) - 1)] : a) },\n  gte: { name: 'v.minValue', args: (a) => a },\n  lte: { name: 'v.maxValue', args: (a) => a },\n  positive: { name: 'v.minValue', args: () => ['1'] },\n  negative: { name: 'v.maxValue', args: () => ['-1'] },\n  nonnegative: { name: 'v.minValue', args: () => ['0'] },\n  nonpositive: { name: 'v.maxValue', args: () => ['0'] },\n};\n\n/** Methods that wrap schemas (modifiers) */\nexport const MODIFIER_METHODS = new Set([\n  'optional',\n  'nullable',\n  'nullish',\n  'default',\n  'catch',\n  'readonly',\n  'brand',\n  'describe',\n  'transform',\n  'refine',\n  'superRefine',\n  'pipe',\n]);\n\n/** Object-specific methods */\nexport const OBJECT_METHODS = new Set([\n  'partial',\n  'required',\n  'pick',\n  'omit',\n  'extend',\n  'merge',\n  'passthrough',\n  'strict',\n  'strip',\n  'catchall',\n  'keyof',\n]);\n","import type { TransformHandler, TransformOptions, TransformResult } from '@schemashift/core';\nimport type { SourceFile } from 'ts-morph';\nimport { ZodToValibotTransformer } from './transformer.js';\n\nexport function createZodToValibotHandler(): TransformHandler {\n  const transformer = new ZodToValibotTransformer();\n  return {\n    transform(sourceFile: SourceFile, _options: TransformOptions): TransformResult {\n      return transformer.transform(sourceFile);\n    },\n  };\n}\n"],"mappings":"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","names":["result"]}

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+import { TransformHandler, TransformResult } from '@schemashift/core';
+import { SourceFile } from 'ts-morph';
+
+declare function createZodToValibotHandler(): TransformHandler;
+
+/**
+ * Zod -> Valibot method name mappings.
+ *
+ * Valibot uses a pipe-based API: v.pipe(v.string(), v.email(), v.minLength(5))
+ * instead of Zod's fluent chain: z.string().email().min(5)
+ *
+ * Factory methods map directly. Validation methods become pipe arguments.
+ */
+/** Zod factory -> Valibot factory */
+declare const FACTORY_MAPPINGS: Record<string, string>;
+/** Zod chain methods -> Valibot pipe validators */
+declare const VALIDATION_MAPPINGS: Record<string, string | null>;
+/** Zod number methods that need specific arg mapping to Valibot */
+declare const NUMBER_VALIDATION_MAPPINGS: Record<string, {
+    name: string;
+    args: (args: string[]) => string[];
+}>;
+/** Methods that wrap schemas (modifiers) */
+declare const MODIFIER_METHODS: Set<string>;
+/** Object-specific methods */
+declare const OBJECT_METHODS: Set<string>;
+
+/**
+ * Zod to Valibot transformer.
+ *
+ * Converts Zod's fluent method chain API to Valibot's pipe-based API.
+ *
+ * Zod:     z.string().email().min(5).max(100)
+ * Valibot: v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))
+ *
+ * Zod:     z.string().optional()
+ * Valibot: v.optional(v.string())
+ *
+ * Zod:     z.object({ name: z.string() }).partial()
+ * Valibot: v.partial(v.object({ name: v.string() }))
+ */
+declare class ZodToValibotTransformer {
+    private errors;
+    private warnings;
+    transform(sourceFile: SourceFile): TransformResult;
+    private updateImports;
+    private transformTypeHelpers;
+    private transformSchemaExpressions;
+    private filterOutermostNodes;
+    private transformCallChain;
+    private transformNestedZodReferences;
+    private categorizeMethod;
+    private applyModifier;
+    private applyObjectMethod;
+    private transformCallChainFallback;
+}
+
+export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ZodToValibotTransformer, createZodToValibotHandler };

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { TransformHandler, TransformResult } from '@schemashift/core';
+import { SourceFile } from 'ts-morph';
+
+declare function createZodToValibotHandler(): TransformHandler;
+
+/**
+ * Zod -> Valibot method name mappings.
+ *
+ * Valibot uses a pipe-based API: v.pipe(v.string(), v.email(), v.minLength(5))
+ * instead of Zod's fluent chain: z.string().email().min(5)
+ *
+ * Factory methods map directly. Validation methods become pipe arguments.
+ */
+/** Zod factory -> Valibot factory */
+declare const FACTORY_MAPPINGS: Record<string, string>;
+/** Zod chain methods -> Valibot pipe validators */
+declare const VALIDATION_MAPPINGS: Record<string, string | null>;
+/** Zod number methods that need specific arg mapping to Valibot */
+declare const NUMBER_VALIDATION_MAPPINGS: Record<string, {
+    name: string;
+    args: (args: string[]) => string[];
+}>;
+/** Methods that wrap schemas (modifiers) */
+declare const MODIFIER_METHODS: Set<string>;
+/** Object-specific methods */
+declare const OBJECT_METHODS: Set<string>;
+
+/**
+ * Zod to Valibot transformer.
+ *
+ * Converts Zod's fluent method chain API to Valibot's pipe-based API.
+ *
+ * Zod:     z.string().email().min(5).max(100)
+ * Valibot: v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))
+ *
+ * Zod:     z.string().optional()
+ * Valibot: v.optional(v.string())
+ *
+ * Zod:     z.object({ name: z.string() }).partial()
+ * Valibot: v.partial(v.object({ name: v.string() }))
+ */
+declare class ZodToValibotTransformer {
+    private errors;
+    private warnings;
+    transform(sourceFile: SourceFile): TransformResult;
+    private updateImports;
+    private transformTypeHelpers;
+    private transformSchemaExpressions;
+    private filterOutermostNodes;
+    private transformCallChain;
+    private transformNestedZodReferences;
+    private categorizeMethod;
+    private applyModifier;
+    private applyObjectMethod;
+    private transformCallChainFallback;
+}
+
+export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ZodToValibotTransformer, createZodToValibotHandler };

package/dist/index.js

@@ -0,0 +1,457 @@
+// src/transformer.ts
+import {
+  isInsideStringLiteral,
+  parseCallChain
+} from "@schemashift/core";
+import { Node } from "ts-morph";
+
+// src/mappings.ts
+var FACTORY_MAPPINGS = {
+  string: "v.string",
+  number: "v.number",
+  boolean: "v.boolean",
+  date: "v.date",
+  bigint: "v.bigint",
+  symbol: "v.symbol",
+  undefined: "v.undefined_",
+  null: "v.null_",
+  void: "v.void_",
+  any: "v.any",
+  unknown: "v.unknown",
+  never: "v.never",
+  nan: "v.nan",
+  literal: "v.literal",
+  enum: "v.picklist",
+  nativeEnum: "v.enum_",
+  array: "v.array",
+  object: "v.object",
+  record: "v.record",
+  tuple: "v.tuple",
+  union: "v.union",
+  discriminatedUnion: "v.variant",
+  intersection: "v.intersect",
+  lazy: "v.lazy",
+  promise: "v.promise",
+  instanceof: "v.instance"
+};
+var VALIDATION_MAPPINGS = {
+  // String validations
+  email: "v.email",
+  url: "v.url",
+  uuid: "v.uuid",
+  cuid: "v.cuid2",
+  cuid2: "v.cuid2",
+  ulid: "v.ulid",
+  regex: "v.regex",
+  ip: "v.ip",
+  datetime: "v.isoDateTime",
+  date: "v.isoDate",
+  time: "v.isoTime",
+  emoji: "v.emoji",
+  includes: "v.includes",
+  startsWith: "v.startsWith",
+  endsWith: "v.endsWith",
+  trim: "v.trim",
+  toLowerCase: "v.toLowerCase",
+  toUpperCase: "v.toUpperCase",
+  // Shared validations (string/number/array/date)
+  min: "v.minLength",
+  // Will be context-sensitive
+  max: "v.maxLength",
+  // Will be context-sensitive
+  length: "v.length",
+  // Number validations
+  gt: "v.minValue",
+  gte: "v.minValue",
+  lt: "v.maxValue",
+  lte: "v.maxValue",
+  int: "v.integer",
+  positive: "v.minValue",
+  negative: "v.maxValue",
+  nonnegative: "v.minValue",
+  nonpositive: "v.maxValue",
+  multipleOf: "v.multipleOf",
+  finite: "v.finite",
+  safe: "v.safeInteger",
+  // Array validations
+  nonempty: "v.nonEmpty",
+  // Schema modifiers (not pipe validators)
+  optional: null,
+  // Handled specially
+  nullable: null,
+  // Handled specially
+  nullish: null,
+  // Handled specially
+  default: null,
+  // Handled specially
+  catch: null,
+  // Handled specially
+  transform: null,
+  // Handled specially
+  refine: null,
+  // Handled specially
+  superRefine: null,
+  // Handled specially
+  brand: null,
+  // Handled specially
+  readonly: null,
+  // Handled specially
+  pipe: null,
+  // Handled specially
+  describe: null,
+  // Handled specially
+  // Object methods
+  partial: null,
+  // Handled specially
+  required: null,
+  // Handled specially
+  pick: null,
+  // Handled specially
+  omit: null,
+  // Handled specially
+  extend: null,
+  // Handled specially
+  merge: null,
+  // Handled specially
+  passthrough: null,
+  // Handled specially
+  strict: null,
+  // Handled specially
+  strip: null,
+  // Handled specially
+  catchall: null,
+  // Handled specially
+  keyof: null,
+  // Handled specially
+  // Array methods
+  element: null
+  // Part of factory
+};
+var NUMBER_VALIDATION_MAPPINGS = {
+  min: { name: "v.minValue", args: (a) => a },
+  max: { name: "v.maxValue", args: (a) => a },
+  gt: { name: "v.minValue", args: (a) => a.length > 0 ? [String(Number(a[0]) + 1)] : a },
+  lt: { name: "v.maxValue", args: (a) => a.length > 0 ? [String(Number(a[0]) - 1)] : a },
+  gte: { name: "v.minValue", args: (a) => a },
+  lte: { name: "v.maxValue", args: (a) => a },
+  positive: { name: "v.minValue", args: () => ["1"] },
+  negative: { name: "v.maxValue", args: () => ["-1"] },
+  nonnegative: { name: "v.minValue", args: () => ["0"] },
+  nonpositive: { name: "v.maxValue", args: () => ["0"] }
+};
+var MODIFIER_METHODS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "nullish",
+  "default",
+  "catch",
+  "readonly",
+  "brand",
+  "describe",
+  "transform",
+  "refine",
+  "superRefine",
+  "pipe"
+]);
+var OBJECT_METHODS = /* @__PURE__ */ new Set([
+  "partial",
+  "required",
+  "pick",
+  "omit",
+  "extend",
+  "merge",
+  "passthrough",
+  "strict",
+  "strip",
+  "catchall",
+  "keyof"
+]);
+
+// src/transformer.ts
+var ZodToValibotTransformer = class {
+  errors = [];
+  warnings = [];
+  transform(sourceFile) {
+    this.errors = [];
+    this.warnings = [];
+    const filePath = sourceFile.getFilePath();
+    const originalCode = sourceFile.getFullText();
+    try {
+      this.updateImports(sourceFile);
+      this.transformTypeHelpers(sourceFile);
+      this.transformSchemaExpressions(sourceFile);
+      return {
+        success: this.errors.length === 0,
+        filePath,
+        originalCode,
+        transformedCode: sourceFile.getFullText(),
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.errors.push({
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      return {
+        success: false,
+        filePath,
+        originalCode,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  updateImports(sourceFile) {
+    const zodImports = sourceFile.getImportDeclarations().filter((imp) => imp.getModuleSpecifierValue() === "zod");
+    for (const imp of zodImports) {
+      imp.setModuleSpecifier("valibot");
+      const namespaceImport = imp.getNamespaceImport();
+      const defaultImport = imp.getDefaultImport();
+      const namedImports = imp.getNamedImports();
+      if (namespaceImport) imp.removeNamespaceImport();
+      if (defaultImport) imp.removeDefaultImport();
+      if (namedImports.length > 0) imp.removeNamedImports();
+      imp.setNamespaceImport("v");
+    }
+  }
+  transformTypeHelpers(sourceFile) {
+    const fullText = sourceFile.getFullText();
+    let newText = fullText;
+    newText = newText.replace(/\bz\.infer</g, "v.InferOutput<");
+    newText = newText.replace(/\bz\.input</g, "v.InferInput<");
+    newText = newText.replace(/\bz\.output</g, "v.InferOutput<");
+    if (newText !== fullText) {
+      sourceFile.replaceWithText(newText);
+    }
+  }
+  transformSchemaExpressions(sourceFile) {
+    const nodesToTransform = [];
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        if (isInsideStringLiteral(node)) return;
+        const text = node.getText();
+        if (text.startsWith("z.")) {
+          nodesToTransform.push(node);
+        }
+      }
+    });
+    const outermost = this.filterOutermostNodes(nodesToTransform);
+    outermost.sort((a, b) => b.getStart() - a.getStart());
+    for (const node of outermost) {
+      this.transformCallChain(node);
+    }
+  }
+  filterOutermostNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+      let isChild = false;
+      for (const other of nodes) {
+        if (other === node) continue;
+        if (other.getStart() <= node.getStart() && other.getEnd() >= node.getEnd()) {
+          isChild = true;
+          break;
+        }
+      }
+      if (!isChild) result.push(node);
+    }
+    return result;
+  }
+  transformCallChain(node) {
+    const chain = parseCallChain(node);
+    if (!chain) {
+      this.transformCallChainFallback(node);
+      return;
+    }
+    if (chain.base !== "z") return;
+    const filePath = node.getSourceFile().getFilePath();
+    const lineNumber = node.getStartLineNumber();
+    const factoryMapping = FACTORY_MAPPINGS[chain.factoryMethod];
+    if (!factoryMapping) {
+      this.warnings.push(
+        `${filePath}:${lineNumber}: Unknown Zod factory z.${chain.factoryMethod}() \u2014 kept as-is`
+      );
+      return;
+    }
+    const factoryType = chain.factoryMethod;
+    const pipeValidators = [];
+    const modifiers = [];
+    const objectMethods = [];
+    for (const method of chain.methods) {
+      const result2 = this.categorizeMethod(method, factoryType, filePath, lineNumber);
+      if (result2.type === "pipe") {
+        pipeValidators.push(result2.code);
+      } else if (result2.type === "modifier") {
+        modifiers.push({ name: result2.name, args: result2.args });
+      } else if (result2.type === "object") {
+        objectMethods.push({ name: result2.name, args: result2.args });
+      }
+    }
+    let result;
+    const factoryCall = `${factoryMapping}(${chain.factoryArgs.join(", ")})`;
+    if (pipeValidators.length > 0) {
+      result = `v.pipe(${factoryCall}, ${pipeValidators.join(", ")})`;
+    } else {
+      result = factoryCall;
+    }
+    for (const objMethod of objectMethods) {
+      result = this.applyObjectMethod(objMethod.name, objMethod.args, result, filePath, lineNumber);
+    }
+    for (const modifier of modifiers) {
+      result = this.applyModifier(modifier.name, modifier.args, result, filePath, lineNumber);
+    }
+    result = this.transformNestedZodReferences(result);
+    node.replaceWithText(result);
+  }
+  transformNestedZodReferences(text) {
+    let result = text;
+    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {
+      const regex = new RegExp(`\\bz\\.${zodName}\\(`, "g");
+      result = result.replace(regex, `${valibotName}(`);
+    }
+    return result;
+  }
+  categorizeMethod(method, factoryType, filePath, lineNumber) {
+    const { name, args } = method;
+    if (MODIFIER_METHODS.has(name)) {
+      return { type: "modifier", name, args };
+    }
+    if (OBJECT_METHODS.has(name)) {
+      return { type: "object", name, args };
+    }
+    if ((factoryType === "number" || factoryType === "bigint") && NUMBER_VALIDATION_MAPPINGS[name]) {
+      const mapping = NUMBER_VALIDATION_MAPPINGS[name];
+      if (!mapping) return { type: "skip" };
+      const mappedArgs = mapping.args(args);
+      return { type: "pipe", code: `${mapping.name}(${mappedArgs.join(", ")})` };
+    }
+    if (factoryType === "string" || factoryType === "array") {
+      if (name === "min") {
+        const vName = factoryType === "string" ? "v.minLength" : "v.minLength";
+        return { type: "pipe", code: `${vName}(${args.join(", ")})` };
+      }
+      if (name === "max") {
+        const vName = factoryType === "string" ? "v.maxLength" : "v.maxLength";
+        return { type: "pipe", code: `${vName}(${args.join(", ")})` };
+      }
+    }
+    const validationMapping = VALIDATION_MAPPINGS[name];
+    if (validationMapping === null) {
+      return { type: "skip" };
+    }
+    if (validationMapping) {
+      return { type: "pipe", code: `${validationMapping}(${args.join(", ")})` };
+    }
+    this.warnings.push(
+      `${filePath}:${lineNumber}: Unknown Zod method .${name}() \u2014 kept as-is in pipe`
+    );
+    return { type: "pipe", code: `/* TODO: .${name}(${args.join(", ")}) */` };
+  }
+  applyModifier(name, args, inner, filePath, lineNumber) {
+    switch (name) {
+      case "optional":
+        return `v.optional(${inner})`;
+      case "nullable":
+        return `v.nullable(${inner})`;
+      case "nullish":
+        return `v.nullish(${inner})`;
+      case "default":
+        return `v.optional(${inner}, ${args.join(", ")})`;
+      case "catch":
+        return `v.fallback(${inner}, ${args.join(", ")})`;
+      case "readonly":
+        return `v.readonly(${inner})`;
+      case "transform":
+        return `v.pipe(${inner}, v.transform(${args.join(", ")}))`;
+      case "refine":
+        if (args.length >= 2) {
+          return `v.pipe(${inner}, v.check(${args[0]}, ${args.slice(1).join(", ")}))`;
+        }
+        return `v.pipe(${inner}, v.check(${args.join(", ")}))`;
+      case "superRefine":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .superRefine() requires manual conversion to Valibot custom validation`
+        );
+        return `v.pipe(${inner}, /* TODO: superRefine -> custom validation */ v.check(${args.join(", ")}))`;
+      case "brand":
+        return `v.pipe(${inner}, v.brand(${args.join(", ")}))`;
+      case "describe":
+        return inner;
+      case "pipe":
+        return `v.pipe(${inner}, ${args.join(", ")})`;
+      default:
+        return inner;
+    }
+  }
+  applyObjectMethod(name, args, inner, filePath, lineNumber) {
+    switch (name) {
+      case "partial":
+        return `v.partial(${inner})`;
+      case "required":
+        return `v.required(${inner})`;
+      case "pick":
+        return `v.pick(${inner}, ${args.join(", ")})`;
+      case "omit":
+        return `v.omit(${inner}, ${args.join(", ")})`;
+      case "extend":
+      case "merge":
+        return `v.merge([${inner}, ${args.join(", ")}])`;
+      case "passthrough":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .passthrough() \u2014 Valibot objects are loose by default, no action needed`
+        );
+        return inner;
+      case "strict":
+        return `v.strict(${inner})`;
+      case "strip":
+        return inner;
+      // Valibot strips unknown by default when using v.object
+      case "catchall":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .catchall() requires manual conversion to Valibot record or custom validation`
+        );
+        return inner;
+      case "keyof":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .keyof() requires manual conversion to v.picklist(Object.keys(...))`
+        );
+        return inner;
+      default:
+        return inner;
+    }
+  }
+  transformCallChainFallback(node) {
+    const text = node.getText();
+    const filePath = node.getSourceFile().getFilePath();
+    const lineNumber = node.getStartLineNumber();
+    let transformed = text;
+    transformed = transformed.replace(/^z\./, "v.");
+    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {
+      const regex = new RegExp(`\\bv\\.${zodName}\\(`, "g");
+      transformed = transformed.replace(regex, `${valibotName}(`);
+    }
+    this.warnings.push(
+      `${filePath}:${lineNumber}: Complex Zod expression used fallback conversion \u2014 manual review recommended`
+    );
+    node.replaceWithText(transformed);
+  }
+};
+
+// src/handler.ts
+function createZodToValibotHandler() {
+  const transformer = new ZodToValibotTransformer();
+  return {
+    transform(sourceFile, _options) {
+      return transformer.transform(sourceFile);
+    }
+  };
+}
+export {
+  FACTORY_MAPPINGS,
+  MODIFIER_METHODS,
+  NUMBER_VALIDATION_MAPPINGS,
+  OBJECT_METHODS,
+  VALIDATION_MAPPINGS,
+  ZodToValibotTransformer,
+  createZodToValibotHandler
+};
+//# sourceMappingURL=index.js.map