@schemashift/core 0.9.0 → 0.11.0

package/dist/index.js

@@ -10,6 +10,9 @@ var LIBRARY_PATTERNS = {
   joi: [/^joi$/, /^@hapi\/joi$/],
   "io-ts": [/^io-ts$/, /^io-ts\//],
   valibot: [/^valibot$/],
+  arktype: [/^arktype$/],
+  superstruct: [/^superstruct$/],
+  effect: [/^@effect\/schema$/],
   v4: [],
   // Target version, not detectable from imports
   unknown: []
@@ -130,6 +133,110 @@ var SchemaAnalyzer = class {
   }
 };
 
+// src/approval.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var ApprovalManager = class {
+  pendingDir;
+  constructor(projectPath) {
+    this.pendingDir = join(projectPath, ".schemashift", "pending");
+  }
+  /**
+   * Create a new migration request for review.
+   */
+  createRequest(from, to, files, requestedBy, metadata) {
+    const id = `mig-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const request = {
+      id,
+      from,
+      to,
+      files,
+      requestedBy,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      metadata
+    };
+    this.ensureDir();
+    const filePath = join(this.pendingDir, `${id}.json`);
+    writeFileSync(filePath, JSON.stringify(request, null, 2), "utf-8");
+    return request;
+  }
+  /**
+   * Review (approve or reject) a pending migration request.
+   */
+  review(decision) {
+    const request = this.getRequest(decision.requestId);
+    if (!request) {
+      throw new Error(`Migration request ${decision.requestId} not found`);
+    }
+    if (request.status !== "pending") {
+      throw new Error(`Migration request ${decision.requestId} is already ${request.status}`);
+    }
+    request.status = decision.status;
+    request.reviewedBy = decision.reviewedBy;
+    request.reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
+    request.reason = decision.reason;
+    const filePath = join(this.pendingDir, `${decision.requestId}.json`);
+    writeFileSync(filePath, JSON.stringify(request, null, 2), "utf-8");
+    return request;
+  }
+  /**
+   * Get a specific migration request by ID.
+   */
+  getRequest(id) {
+    const filePath = join(this.pendingDir, `${id}.json`);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * List all migration requests, optionally filtered by status.
+   */
+  listRequests(status) {
+    if (!existsSync(this.pendingDir)) {
+      return [];
+    }
+    const files = readdirSync(this.pendingDir).filter((f) => f.endsWith(".json"));
+    const requests = [];
+    for (const file of files) {
+      const content = readFileSync(join(this.pendingDir, file), "utf-8");
+      const request = JSON.parse(content);
+      if (!status || request.status === status) {
+        requests.push(request);
+      }
+    }
+    return requests.sort(
+      (a, b) => new Date(b.requestedAt).getTime() - new Date(a.requestedAt).getTime()
+    );
+  }
+  /**
+   * Get summary counts of all requests.
+   */
+  getSummary() {
+    const all = this.listRequests();
+    return {
+      pending: all.filter((r) => r.status === "pending").length,
+      approved: all.filter((r) => r.status === "approved").length,
+      rejected: all.filter((r) => r.status === "rejected").length,
+      total: all.length
+    };
+  }
+  /**
+   * Check if a migration has been approved.
+   */
+  isApproved(requestId) {
+    const request = this.getRequest(requestId);
+    return request?.status === "approved";
+  }
+  ensureDir() {
+    if (!existsSync(this.pendingDir)) {
+      mkdirSync(this.pendingDir, { recursive: true });
+    }
+  }
+};
+
 // src/ast-utils.ts
 import { Node as NodeUtils } from "ts-morph";
 function parseCallChain(node) {
@@ -266,8 +373,8 @@ function transformMethodChain(chain, newBase, factoryMapper, methodMapper) {
 
 // src/audit-log.ts
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
 var AUDIT_DIR = ".schemashift";
 var AUDIT_FILE = "audit-log.json";
 var AUDIT_VERSION = 1;
@@ -275,8 +382,8 @@ var MigrationAuditLog = class {
   logDir;
   logPath;
   constructor(projectPath) {
-    this.logDir = join(projectPath, AUDIT_DIR);
-    this.logPath = join(this.logDir, AUDIT_FILE);
+    this.logDir = join2(projectPath, AUDIT_DIR);
+    this.logPath = join2(this.logDir, AUDIT_FILE);
   }
   /**
    * Append a new entry to the audit log.
@@ -304,18 +411,19 @@ var MigrationAuditLog = class {
       errorCount: params.errorCount,
       riskScore: params.riskScore,
       duration: params.duration,
-      user: this.getCurrentUser()
+      user: this.getCurrentUser(),
+      metadata: params.metadata || this.collectMetadata()
     };
   }
   /**
    * Read the current audit log.
    */
   read() {
-    if (!existsSync(this.logPath)) {
+    if (!existsSync2(this.logPath)) {
       return { version: AUDIT_VERSION, entries: [] };
     }
     try {
-      const content = readFileSync(this.logPath, "utf-8");
+      const content = readFileSync2(this.logPath, "utf-8");
       if (!content.trim()) {
         return { version: AUDIT_VERSION, entries: [] };
       }
@@ -346,17 +454,72 @@ var MigrationAuditLog = class {
       migrationPaths
     };
   }
+  /**
+   * Export audit log as JSON string.
+   */
+  exportJson() {
+    const log = this.read();
+    return JSON.stringify(log, null, 2);
+  }
+  /**
+   * Export audit log as CSV string.
+   */
+  exportCsv() {
+    const log = this.read();
+    const headers = [
+      "timestamp",
+      "migrationId",
+      "filePath",
+      "action",
+      "from",
+      "to",
+      "success",
+      "warningCount",
+      "errorCount",
+      "riskScore",
+      "user",
+      "duration"
+    ];
+    const rows = log.entries.map(
+      (e) => headers.map((h) => {
+        const val = e[h];
+        if (val === void 0 || val === null) return "";
+        return String(val).includes(",") ? `"${String(val)}"` : String(val);
+      }).join(",")
+    );
+    return [headers.join(","), ...rows].join("\n");
+  }
+  /**
+   * Get entries filtered by date range.
+   */
+  getByDateRange(start, end) {
+    const log = this.read();
+    return log.entries.filter((e) => {
+      const ts = new Date(e.timestamp);
+      return ts >= start && ts <= end;
+    });
+  }
   /**
    * Clear the audit log.
    */
   clear() {
     this.write({ version: AUDIT_VERSION, entries: [] });
   }
+  collectMetadata() {
+    return {
+      hostname: process.env.HOSTNAME || void 0,
+      nodeVersion: process.version,
+      ciJobId: process.env.CI_JOB_ID || process.env.GITHUB_RUN_ID || void 0,
+      ciProvider: process.env.GITHUB_ACTIONS ? "github" : process.env.GITLAB_CI ? "gitlab" : process.env.CIRCLECI ? "circleci" : process.env.JENKINS_URL ? "jenkins" : void 0,
+      gitBranch: process.env.GITHUB_REF_NAME || process.env.CI_COMMIT_BRANCH || void 0,
+      gitCommit: process.env.GITHUB_SHA || process.env.CI_COMMIT_SHA || void 0
+    };
+  }
   write(log) {
-    if (!existsSync(this.logDir)) {
-      mkdirSync(this.logDir, { recursive: true });
+    if (!existsSync2(this.logDir)) {
+      mkdirSync2(this.logDir, { recursive: true });
     }
-    writeFileSync(this.logPath, JSON.stringify(log, null, 2));
+    writeFileSync2(this.logPath, JSON.stringify(log, null, 2));
   }
   hashContent(content) {
     return createHash("sha256").update(content).digest("hex").substring(0, 16);
@@ -789,12 +952,12 @@ var MigrationChain = class {
 };
 
 // src/compatibility.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 
 // src/ecosystem.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 var ECOSYSTEM_RULES = [
   // ORM integrations
   {
@@ -970,6 +1133,191 @@ var ECOSYSTEM_RULES = [
       severity: "error"
     })
   },
+  // Zod-based HTTP/API clients
+  {
+    package: "zodios",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "Zodios uses Zod schemas for API contract definitions. Zod v4 type changes may break contracts.",
+      suggestion: "Upgrade Zodios to a Zod v4-compatible version and verify all API contracts.",
+      severity: "warning",
+      upgradeCommand: "npm install @zodios/core@latest"
+    })
+  },
+  {
+    package: "@zodios/core",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "@zodios/core uses Zod schemas for API contract definitions. Zod v4 type changes may break contracts.",
+      suggestion: "Upgrade @zodios/core to a Zod v4-compatible version and verify all API contracts.",
+      severity: "warning",
+      upgradeCommand: "npm install @zodios/core@latest"
+    })
+  },
+  {
+    package: "@ts-rest/core",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "@ts-rest/core uses Zod for contract definitions. Zod v4 type incompatibilities may break runtime validation.",
+      suggestion: "Upgrade @ts-rest/core to a version with Zod v4 support.",
+      severity: "warning",
+      upgradeCommand: "npm install @ts-rest/core@latest"
+    })
+  },
+  {
+    package: "trpc-openapi",
+    category: "openapi",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "trpc-openapi needs a v4-compatible version for Zod v4.",
+      suggestion: "Check for a Zod v4-compatible version of trpc-openapi before upgrading.",
+      severity: "warning",
+      upgradeCommand: "npm install trpc-openapi@latest"
+    })
+  },
+  // Form data and URL state libraries
+  {
+    package: "zod-form-data",
+    category: "form",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "zod-form-data relies on Zod v3 internals (_def) which moved to _zod.def in v4.",
+      suggestion: "Upgrade zod-form-data to a Zod v4-compatible version.",
+      severity: "error",
+      upgradeCommand: "npm install zod-form-data@latest"
+    })
+  },
+  {
+    package: "@conform-to/zod",
+    category: "form",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "@conform-to/zod may have Zod v4 compatibility issues.",
+      suggestion: "Upgrade @conform-to/zod to the latest version with Zod v4 support.",
+      severity: "warning",
+      upgradeCommand: "npm install @conform-to/zod@latest"
+    })
+  },
+  {
+    package: "nuqs",
+    category: "validation-util",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "nuqs uses Zod for URL state parsing. Zod v4 changes may affect URL parameter validation.",
+      suggestion: "Upgrade nuqs to a version with Zod v4 support.",
+      severity: "warning",
+      upgradeCommand: "npm install nuqs@latest"
+    })
+  },
+  // Server action / routing integrations
+  {
+    package: "next-safe-action",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "next-safe-action uses Zod for input validation. Zod v4 type changes may break action definitions.",
+      suggestion: "Upgrade next-safe-action to the latest version with Zod v4 support.",
+      severity: "warning",
+      upgradeCommand: "npm install next-safe-action@latest"
+    })
+  },
+  {
+    package: "@tanstack/router",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "@tanstack/router uses Zod for route parameter validation. Zod v4 changes may affect type inference.",
+      suggestion: "Upgrade @tanstack/router to a version with Zod v4 support.",
+      severity: "warning",
+      upgradeCommand: "npm install @tanstack/router@latest"
+    })
+  },
+  {
+    package: "@tanstack/react-query",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "@tanstack/react-query may use Zod for query key/param validation via integrations.",
+      suggestion: "Verify any Zod-based query validation still works after the Zod v4 upgrade.",
+      severity: "info"
+    })
+  },
+  {
+    package: "fastify-type-provider-zod",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "fastify-type-provider-zod needs a Zod v4-compatible version.",
+      suggestion: "Upgrade fastify-type-provider-zod to a version supporting Zod v4.",
+      severity: "warning",
+      upgradeCommand: "npm install fastify-type-provider-zod@latest"
+    })
+  },
+  {
+    package: "zod-i18n-map",
+    category: "validation-util",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: 'zod-i18n-map uses Zod v3 error map format. Error messages changed in v4 (e.g., "Required" is now descriptive).',
+      suggestion: "Check for a Zod v4-compatible version of zod-i18n-map or update custom error maps.",
+      severity: "warning",
+      upgradeCommand: "npm install zod-i18n-map@latest"
+    })
+  },
+  {
+    package: "openapi-zod-client",
+    category: "openapi",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "openapi-zod-client generates Zod v3 schemas from OpenAPI specs. Generated code may need regeneration.",
+      suggestion: "Upgrade openapi-zod-client and regenerate schemas for Zod v4 compatibility.",
+      severity: "warning",
+      upgradeCommand: "npm install openapi-zod-client@latest"
+    })
+  },
+  // Schema library detection for cross-library migrations
+  {
+    package: "@effect/schema",
+    category: "validation-util",
+    migrations: ["io-ts->zod"],
+    check: () => ({
+      issue: "@effect/schema detected \u2014 this is the successor to io-ts/fp-ts. Consider migrating to Effect Schema instead of Zod if you prefer FP patterns.",
+      suggestion: "If using fp-ts patterns heavily, consider Effect Schema as the migration target instead of Zod.",
+      severity: "info"
+    })
+  },
+  {
+    package: "arktype",
+    category: "validation-util",
+    migrations: ["zod->valibot", "zod-v3->v4"],
+    check: (_version, migration) => {
+      if (migration === "zod->valibot") {
+        return {
+          issue: "ArkType detected alongside Zod. Consider ArkType as a migration target \u2014 it offers 100x faster validation and Standard Schema support.",
+          suggestion: "Consider migrating to ArkType for performance-critical paths, or keep Zod for ecosystem compatibility.",
+          severity: "info"
+        };
+      }
+      return {
+        issue: "ArkType detected alongside Zod. ArkType supports Standard Schema, making it interoperable with Zod v4.",
+        suggestion: "No action needed \u2014 ArkType and Zod v4 can coexist via Standard Schema.",
+        severity: "info"
+      };
+    }
+  },
+  {
+    package: "superstruct",
+    category: "validation-util",
+    migrations: ["yup->zod", "joi->zod"],
+    check: () => ({
+      issue: "Superstruct detected in the project. Consider migrating Superstruct schemas to Zod as well for a unified validation approach.",
+      suggestion: "Use SchemaShift to migrate Superstruct schemas alongside Yup/Joi schemas.",
+      severity: "info"
+    })
+  },
   // Additional validation utilities
   {
     package: "zod-to-json-schema",
@@ -1007,13 +1355,13 @@ var EcosystemAnalyzer = class {
     const dependencies = [];
     const warnings = [];
     const blockers = [];
-    const pkgPath = join2(projectPath, "package.json");
-    if (!existsSync2(pkgPath)) {
+    const pkgPath = join3(projectPath, "package.json");
+    if (!existsSync3(pkgPath)) {
       return { dependencies, warnings, blockers };
     }
     let allDeps = {};
     try {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     } catch {
       return { dependencies, warnings, blockers };
@@ -1134,10 +1482,10 @@ var CompatibilityAnalyzer = class {
   ecosystemAnalyzer = new EcosystemAnalyzer();
   detectVersions(projectPath) {
     const versions = [];
-    const pkgPath = join3(projectPath, "package.json");
-    if (!existsSync3(pkgPath)) return versions;
+    const pkgPath = join4(projectPath, "package.json");
+    if (!existsSync4(pkgPath)) return versions;
     try {
-      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
       const knownLibs = ["zod", "yup", "joi", "io-ts", "valibot"];
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       for (const lib of knownLibs) {
@@ -1358,9 +1706,115 @@ async function loadConfig(configPath) {
   };
 }
 
+// src/cross-field-patterns.ts
+function requireIf(conditionField, requiredField) {
+  return {
+    name: `requireIf(${conditionField}, ${requiredField})`,
+    description: `${requiredField} is required when ${conditionField} is truthy`,
+    zodCode: [
+      ".superRefine((data, ctx) => {",
+      `  if (data.${conditionField} && !data.${requiredField}) {`,
+      "    ctx.addIssue({",
+      "      code: z.ZodIssueCode.custom,",
+      `      message: '${requiredField} is required when ${conditionField} is set',`,
+      `      path: ['${requiredField}'],`,
+      "    });",
+      "  }",
+      "})"
+    ].join("\n")
+  };
+}
+function requireOneOf(fields) {
+  const fieldList = fields.map((f) => `'${f}'`).join(", ");
+  const conditions = fields.map((f) => `data.${f}`).join(" || ");
+  return {
+    name: `requireOneOf(${fields.join(", ")})`,
+    description: `At least one of [${fields.join(", ")}] must be provided`,
+    zodCode: [
+      ".superRefine((data, ctx) => {",
+      `  if (!(${conditions})) {`,
+      "    ctx.addIssue({",
+      "      code: z.ZodIssueCode.custom,",
+      `      message: 'At least one of [${fields.join(", ")}] is required',`,
+      `      path: [${fieldList}],`,
+      "    });",
+      "  }",
+      "})"
+    ].join("\n")
+  };
+}
+function mutuallyExclusive(fields) {
+  const checks = fields.map((f) => `(data.${f} ? 1 : 0)`).join(" + ");
+  return {
+    name: `mutuallyExclusive(${fields.join(", ")})`,
+    description: `Only one of [${fields.join(", ")}] can be set at a time`,
+    zodCode: [
+      ".superRefine((data, ctx) => {",
+      `  const count = ${checks};`,
+      "  if (count > 1) {",
+      "    ctx.addIssue({",
+      "      code: z.ZodIssueCode.custom,",
+      `      message: 'Only one of [${fields.join(", ")}] can be set at a time',`,
+      "    });",
+      "  }",
+      "})"
+    ].join("\n")
+  };
+}
+function dependentFields(primaryField, dependents) {
+  const checks = dependents.map(
+    (f) => `  if (!data.${f}) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: '${f} is required when ${primaryField} is set', path: ['${f}'] });
+  }`
+  ).join("\n");
+  return {
+    name: `dependentFields(${primaryField} -> ${dependents.join(", ")})`,
+    description: `When ${primaryField} is set, [${dependents.join(", ")}] are required`,
+    zodCode: [
+      ".superRefine((data, ctx) => {",
+      `  if (data.${primaryField}) {`,
+      checks,
+      "  }",
+      "})"
+    ].join("\n")
+  };
+}
+function conditionalValidation(conditionField, conditionValue, targetField, validationMessage) {
+  return {
+    name: `conditionalValidation(${conditionField}=${conditionValue} -> ${targetField})`,
+    description: `Validate ${targetField} when ${conditionField} equals ${conditionValue}`,
+    zodCode: [
+      ".superRefine((data, ctx) => {",
+      `  if (data.${conditionField} === ${conditionValue} && !data.${targetField}) {`,
+      "    ctx.addIssue({",
+      "      code: z.ZodIssueCode.custom,",
+      `      message: '${validationMessage}',`,
+      `      path: ['${targetField}'],`,
+      "    });",
+      "  }",
+      "})"
+    ].join("\n")
+  };
+}
+function suggestCrossFieldPattern(whenCode) {
+  const booleanMatch = whenCode.match(/\.when\(['"](\w+)['"]\s*,\s*\{[^}]*is:\s*true/);
+  if (booleanMatch?.[1]) {
+    const field = booleanMatch[1];
+    return requireIf(field, "targetField");
+  }
+  const multiFieldMatch = whenCode.match(/\.when\(\[([^\]]+)\]/);
+  if (multiFieldMatch?.[1]) {
+    const fields = multiFieldMatch[1].split(",").map((f) => f.trim().replace(/['"]/g, "")).filter(Boolean);
+    if (fields.length > 1) {
+      return dependentFields(fields[0] ?? "primary", fields.slice(1));
+    }
+  }
+  return null;
+}
+
 // src/dependency-graph.ts
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "fs";
-import { join as join4, resolve } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join5, resolve } from "path";
 var SchemaDependencyResolver = class {
   resolve(project, filePaths) {
     const fileSet = new Set(filePaths);
@@ -1487,38 +1941,38 @@ function computeParallelBatches(packages, suggestedOrder) {
 }
 var MonorepoResolver = class {
   detect(projectPath) {
-    const pkgPath = join4(projectPath, "package.json");
-    if (existsSync4(pkgPath)) {
+    const pkgPath = join5(projectPath, "package.json");
+    if (existsSync5(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.workspaces) return true;
       } catch {
       }
     }
-    if (existsSync4(join4(projectPath, "pnpm-workspace.yaml"))) return true;
+    if (existsSync5(join5(projectPath, "pnpm-workspace.yaml"))) return true;
     return false;
   }
   /**
    * Detect which workspace manager is being used.
    */
   detectManager(projectPath) {
-    if (existsSync4(join4(projectPath, "pnpm-workspace.yaml"))) return "pnpm";
-    const pkgPath = join4(projectPath, "package.json");
-    if (existsSync4(pkgPath)) {
+    if (existsSync5(join5(projectPath, "pnpm-workspace.yaml"))) return "pnpm";
+    const pkgPath = join5(projectPath, "package.json");
+    if (existsSync5(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.packageManager?.startsWith("yarn")) return "yarn";
         if (pkg.packageManager?.startsWith("pnpm")) return "pnpm";
       } catch {
       }
     }
-    if (existsSync4(join4(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync4(join4(projectPath, "yarn.lock"))) return "yarn";
+    if (existsSync5(join5(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync5(join5(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   }
   analyze(projectPath) {
-    const pkgPath = join4(projectPath, "package.json");
-    if (!existsSync4(pkgPath)) {
+    const pkgPath = join5(projectPath, "package.json");
+    if (!existsSync5(pkgPath)) {
       return { isMonorepo: false, packages: [], suggestedOrder: [] };
     }
     let workspaceGlobs;
@@ -1533,10 +1987,10 @@ var MonorepoResolver = class {
     const packages = [];
     const resolvedDirs = this.resolveWorkspaceDirs(projectPath, workspaceGlobs);
     for (const dir of resolvedDirs) {
-      const wsPkgPath = join4(dir, "package.json");
-      if (!existsSync4(wsPkgPath)) continue;
+      const wsPkgPath = join5(dir, "package.json");
+      if (!existsSync5(wsPkgPath)) continue;
       try {
-        const wsPkg = JSON.parse(readFileSync4(wsPkgPath, "utf-8"));
+        const wsPkg = JSON.parse(readFileSync5(wsPkgPath, "utf-8"));
         if (!wsPkg.name) continue;
         const allDeps = { ...wsPkg.dependencies, ...wsPkg.devDependencies };
         const depNames = Object.keys(allDeps);
@@ -1580,14 +2034,14 @@ var MonorepoResolver = class {
    * Supports: npm/yarn workspaces (package.json), pnpm-workspace.yaml
    */
   resolveWorkspaceGlobs(projectPath) {
-    const pnpmPath = join4(projectPath, "pnpm-workspace.yaml");
-    if (existsSync4(pnpmPath)) {
+    const pnpmPath = join5(projectPath, "pnpm-workspace.yaml");
+    if (existsSync5(pnpmPath)) {
       return this.parsePnpmWorkspace(pnpmPath);
     }
-    const pkgPath = join4(projectPath, "package.json");
-    if (existsSync4(pkgPath)) {
+    const pkgPath = join5(projectPath, "package.json");
+    if (existsSync5(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.workspaces) {
           return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages;
         }
@@ -1606,7 +2060,7 @@ var MonorepoResolver = class {
    * ```
    */
   parsePnpmWorkspace(filePath) {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const globs = [];
     let inPackages = false;
     for (const line of content.split("\n")) {
@@ -1632,13 +2086,13 @@ var MonorepoResolver = class {
     for (const glob of globs) {
       const clean = glob.replace(/\/?\*$/, "");
       const base = resolve(projectPath, clean);
-      if (!existsSync4(base)) continue;
+      if (!existsSync5(base)) continue;
       if (glob.endsWith("*")) {
         try {
-          const entries = readdirSync(base, { withFileTypes: true });
+          const entries = readdirSync2(base, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              dirs.push(join4(base, entry.name));
+              dirs.push(join5(base, entry.name));
             }
           }
         } catch {
@@ -1652,8 +2106,8 @@ var MonorepoResolver = class {
 };
 
 // src/detailed-analyzer.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 var COMPLEXITY_CHAIN_WEIGHT = 2;
 var COMPLEXITY_DEPTH_WEIGHT = 3;
 var COMPLEXITY_VALIDATION_WEIGHT = 1;
@@ -1718,10 +2172,10 @@ var DetailedAnalyzer = class {
   }
   detectLibraryVersions(projectPath) {
     const versions = [];
-    const pkgPath = join5(projectPath, "package.json");
-    if (!existsSync5(pkgPath)) return versions;
+    const pkgPath = join6(projectPath, "package.json");
+    if (!existsSync6(pkgPath)) return versions;
     try {
-      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       const knownLibs = ["zod", "yup", "joi", "io-ts", "valibot"];
       const allDeps = {
         ...pkg.dependencies,
@@ -1894,36 +2348,195 @@ var DetailedAnalyzer = class {
   }
 };
 
-// src/form-resolver-migrator.ts
-var RESOLVER_MAPPINGS = {
-  "yup->zod": [
-    {
-      fromImport: "@hookform/resolvers/yup",
-      toImport: "@hookform/resolvers/zod",
-      fromResolver: "yupResolver",
-      toResolver: "zodResolver"
+// src/drift-detector.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, relative } from "path";
+var SNAPSHOT_DIR = ".schemashift";
+var SNAPSHOT_FILE = "schema-snapshot.json";
+var SNAPSHOT_VERSION = 1;
+var DriftDetector = class {
+  snapshotDir;
+  snapshotPath;
+  constructor(projectPath) {
+    this.snapshotDir = join7(projectPath, SNAPSHOT_DIR);
+    this.snapshotPath = join7(this.snapshotDir, SNAPSHOT_FILE);
+  }
+  /**
+   * Take a snapshot of the current schema state
+   */
+  snapshot(files, projectPath) {
+    const schemas = [];
+    for (const filePath of files) {
+      if (!existsSync7(filePath)) continue;
+      const content = readFileSync7(filePath, "utf-8");
+      const library = this.detectLibraryFromContent(content);
+      if (library === "unknown") continue;
+      const schemaNames = this.extractSchemaNames(content);
+      schemas.push({
+        filePath: relative(projectPath, filePath),
+        library,
+        contentHash: this.hashContent(content),
+        schemaCount: schemaNames.length,
+        schemaNames
+      });
     }
-  ],
-  "joi->zod": [
-    {
-      fromImport: "@hookform/resolvers/joi",
-      toImport: "@hookform/resolvers/zod",
-      fromResolver: "joiResolver",
-      toResolver: "zodResolver"
+    const snapshot = {
+      version: SNAPSHOT_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath,
+      schemas
+    };
+    return snapshot;
+  }
+  /**
+   * Save a snapshot to disk
+   */
+  saveSnapshot(snapshot) {
+    if (!existsSync7(this.snapshotDir)) {
+      mkdirSync3(this.snapshotDir, { recursive: true });
     }
-  ],
-  "zod->valibot": [
-    {
-      fromImport: "@hookform/resolvers/zod",
-      toImport: "@hookform/resolvers/valibot",
-      fromResolver: "zodResolver",
-      toResolver: "valibotResolver"
+    writeFileSync3(this.snapshotPath, JSON.stringify(snapshot, null, 2));
+  }
+  /**
+   * Load saved snapshot from disk
+   */
+  loadSnapshot() {
+    if (!existsSync7(this.snapshotPath)) {
+      return null;
     }
-  ]
-};
-var TODO_PATTERNS = [
-  {
-    pattern: /from\s+['"]formik['"]/,
+    try {
+      const content = readFileSync7(this.snapshotPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Compare current state against saved snapshot
+   */
+  detect(currentFiles, projectPath) {
+    const saved = this.loadSnapshot();
+    if (!saved) {
+      return {
+        hasDrift: false,
+        added: [],
+        removed: [],
+        modified: [],
+        unchanged: 0,
+        totalFiles: 0,
+        snapshotTimestamp: ""
+      };
+    }
+    const current = this.snapshot(currentFiles, projectPath);
+    return this.compareSnapshots(saved, current);
+  }
+  /**
+   * Compare two snapshots and return drift results
+   */
+  compareSnapshots(baseline, current) {
+    const baselineMap = new Map(baseline.schemas.map((s) => [s.filePath, s]));
+    const currentMap = new Map(current.schemas.map((s) => [s.filePath, s]));
+    const added = [];
+    const removed = [];
+    const modified = [];
+    let unchanged = 0;
+    for (const [path, currentFile] of currentMap) {
+      const baselineFile = baselineMap.get(path);
+      if (!baselineFile) {
+        added.push(currentFile);
+      } else if (currentFile.contentHash !== baselineFile.contentHash) {
+        const addedSchemas = currentFile.schemaNames.filter(
+          (n) => !baselineFile.schemaNames.includes(n)
+        );
+        const removedSchemas = baselineFile.schemaNames.filter(
+          (n) => !currentFile.schemaNames.includes(n)
+        );
+        modified.push({
+          filePath: path,
+          library: currentFile.library,
+          previousHash: baselineFile.contentHash,
+          currentHash: currentFile.contentHash,
+          previousSchemaCount: baselineFile.schemaCount,
+          currentSchemaCount: currentFile.schemaCount,
+          addedSchemas,
+          removedSchemas
+        });
+      } else {
+        unchanged++;
+      }
+    }
+    for (const [path, baselineFile] of baselineMap) {
+      if (!currentMap.has(path)) {
+        removed.push(baselineFile);
+      }
+    }
+    return {
+      hasDrift: added.length > 0 || removed.length > 0 || modified.length > 0,
+      added,
+      removed,
+      modified,
+      unchanged,
+      totalFiles: currentMap.size,
+      snapshotTimestamp: baseline.timestamp
+    };
+  }
+  extractSchemaNames(content) {
+    const names = [];
+    const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*(?:z\.|yup\.|Joi\.|t\.|v\.|type\(|object\(|string\(|S\.)/g;
+    for (const match of content.matchAll(pattern)) {
+      if (match[1]) names.push(match[1]);
+    }
+    return names;
+  }
+  detectLibraryFromContent(content) {
+    if (/from\s*['"]zod['"]/.test(content) || /\bz\./.test(content)) return "zod";
+    if (/from\s*['"]yup['"]/.test(content) || /\byup\./.test(content)) return "yup";
+    if (/from\s*['"]joi['"]/.test(content) || /\bJoi\./.test(content)) return "joi";
+    if (/from\s*['"]io-ts['"]/.test(content) || /\bt\./.test(content) && /from\s*['"]io-ts/.test(content))
+      return "io-ts";
+    if (/from\s*['"]valibot['"]/.test(content) || /\bv\./.test(content) && /from\s*['"]valibot/.test(content))
+      return "valibot";
+    if (/from\s*['"]arktype['"]/.test(content)) return "arktype";
+    if (/from\s*['"]superstruct['"]/.test(content)) return "superstruct";
+    if (/from\s*['"]@effect\/schema['"]/.test(content)) return "effect";
+    return "unknown";
+  }
+  hashContent(content) {
+    return createHash2("sha256").update(content).digest("hex").substring(0, 16);
+  }
+};
+
+// src/form-resolver-migrator.ts
+var RESOLVER_MAPPINGS = {
+  "yup->zod": [
+    {
+      fromImport: "@hookform/resolvers/yup",
+      toImport: "@hookform/resolvers/zod",
+      fromResolver: "yupResolver",
+      toResolver: "zodResolver"
+    }
+  ],
+  "joi->zod": [
+    {
+      fromImport: "@hookform/resolvers/joi",
+      toImport: "@hookform/resolvers/zod",
+      fromResolver: "joiResolver",
+      toResolver: "zodResolver"
+    }
+  ],
+  "zod->valibot": [
+    {
+      fromImport: "@hookform/resolvers/zod",
+      toImport: "@hookform/resolvers/valibot",
+      fromResolver: "zodResolver",
+      toResolver: "valibotResolver"
+    }
+  ]
+};
+var TODO_PATTERNS = [
+  {
+    pattern: /from\s+['"]formik['"]/,
     comment: "/* TODO(schemashift): Formik is unmaintained. Consider migrating to React Hook Form with zodResolver */"
   },
   {
@@ -2255,17 +2868,676 @@ var GovernanceEngine = class {
   }
 };
 
+// src/governance-fixer.ts
+var GovernanceFixer = class {
+  defaultMaxLength = 1e4;
+  /**
+   * Set the default max length appended by the require-max-length fix.
+   */
+  setDefaultMaxLength(length) {
+    this.defaultMaxLength = length;
+  }
+  /**
+   * Check if a violation is auto-fixable.
+   */
+  canFix(violation) {
+    return [
+      "no-any-schemas",
+      "require-descriptions",
+      "require-max-length",
+      "naming-convention",
+      "no-any",
+      "require-description",
+      "required-validations",
+      "require-safeParse"
+    ].includes(violation.rule);
+  }
+  /**
+   * Fix a single violation in a source file.
+   * Returns the fixed code for the entire file.
+   */
+  fix(violation, sourceCode) {
+    switch (violation.rule) {
+      case "no-any-schemas":
+      case "no-any":
+        return this.fixNoAny(violation, sourceCode);
+      case "require-descriptions":
+      case "require-description":
+        return this.fixRequireDescription(violation, sourceCode);
+      case "require-max-length":
+      case "required-validations":
+        return this.fixRequireMaxLength(violation, sourceCode);
+      case "naming-convention":
+        return this.fixNamingConvention(violation, sourceCode);
+      case "require-safeParse":
+        return this.fixRequireSafeParse(violation, sourceCode);
+      default:
+        return {
+          success: false,
+          explanation: `No auto-fix available for rule: ${violation.rule}`,
+          rule: violation.rule,
+          lineNumber: violation.lineNumber
+        };
+    }
+  }
+  /**
+   * Fix all fixable violations in a source file.
+   * Applies fixes from bottom to top to preserve line numbers.
+   */
+  fixAll(violations, sourceCode) {
+    const fixable = violations.filter((v) => this.canFix(v));
+    const results = [];
+    let currentCode = sourceCode;
+    let fixed = 0;
+    const sorted = [...fixable].sort((a, b) => b.lineNumber - a.lineNumber);
+    for (const violation of sorted) {
+      const result = this.fix(violation, currentCode);
+      results.push(result);
+      if (result.success && result.fixedCode) {
+        currentCode = result.fixedCode;
+        fixed++;
+      }
+    }
+    return {
+      totalViolations: violations.length,
+      fixed,
+      skipped: violations.length - fixed,
+      results
+    };
+  }
+  fixNoAny(violation, sourceCode) {
+    const lines = sourceCode.split("\n");
+    const lineIndex = violation.lineNumber - 1;
+    const line = lines[lineIndex];
+    if (!line) {
+      return {
+        success: false,
+        explanation: `Line ${violation.lineNumber} not found`,
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    let fixedLine = line;
+    let explanation = "";
+    if (/\bz\.any\(\)/.test(line)) {
+      fixedLine = line.replace(/\bz\.any\(\)/, "z.unknown()");
+      explanation = "Replaced z.any() with z.unknown() for type safety";
+    } else if (/\byup\.mixed\(\)/.test(line)) {
+      fixedLine = line.replace(/\byup\.mixed\(\)/, "yup.mixed().required()");
+      explanation = "Added .required() constraint to yup.mixed()";
+    } else if (/\bt\.any\b/.test(line)) {
+      fixedLine = line.replace(/\bt\.any\b/, "t.unknown");
+      explanation = "Replaced t.any with t.unknown for type safety";
+    } else if (/\bv\.any\(\)/.test(line)) {
+      fixedLine = line.replace(/\bv\.any\(\)/, "v.unknown()");
+      explanation = "Replaced v.any() with v.unknown() for type safety";
+    } else {
+      return {
+        success: false,
+        explanation: "Could not identify any-type pattern to fix",
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    lines[lineIndex] = fixedLine;
+    return {
+      success: true,
+      fixedCode: lines.join("\n"),
+      explanation,
+      rule: violation.rule,
+      lineNumber: violation.lineNumber
+    };
+  }
+  fixRequireDescription(violation, sourceCode) {
+    const lines = sourceCode.split("\n");
+    const lineIndex = violation.lineNumber - 1;
+    const line = lines[lineIndex];
+    if (!line) {
+      return {
+        success: false,
+        explanation: `Line ${violation.lineNumber} not found`,
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    let endLineIndex = lineIndex;
+    for (let i = lineIndex; i < lines.length && i < lineIndex + 20; i++) {
+      if (lines[i]?.includes(";")) {
+        endLineIndex = i;
+        break;
+      }
+    }
+    const endLine = lines[endLineIndex] ?? "";
+    const schemaName = violation.schemaName || "schema";
+    const description = `${schemaName} schema`;
+    const semicolonIndex = endLine.lastIndexOf(";");
+    if (semicolonIndex >= 0) {
+      lines[endLineIndex] = `${endLine.slice(0, semicolonIndex)}.describe('${description}')${endLine.slice(semicolonIndex)}`;
+    } else {
+      lines[endLineIndex] = `${endLine}.describe('${description}')`;
+    }
+    return {
+      success: true,
+      fixedCode: lines.join("\n"),
+      explanation: `Added .describe('${description}') to ${schemaName}`,
+      rule: violation.rule,
+      lineNumber: violation.lineNumber
+    };
+  }
+  fixRequireMaxLength(violation, sourceCode) {
+    const lines = sourceCode.split("\n");
+    const lineIndex = violation.lineNumber - 1;
+    const line = lines[lineIndex];
+    if (!line) {
+      return {
+        success: false,
+        explanation: `Line ${violation.lineNumber} not found`,
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    if (/z\.string\(\)/.test(line)) {
+      lines[lineIndex] = line.replace(/z\.string\(\)/, `z.string().max(${this.defaultMaxLength})`);
+      return {
+        success: true,
+        fixedCode: lines.join("\n"),
+        explanation: `Added .max(${this.defaultMaxLength}) to string schema`,
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    return {
+      success: false,
+      explanation: "Could not find z.string() pattern to fix on this line",
+      rule: violation.rule,
+      lineNumber: violation.lineNumber
+    };
+  }
+  fixNamingConvention(violation, sourceCode) {
+    const schemaName = violation.schemaName;
+    if (!schemaName) {
+      return {
+        success: false,
+        explanation: "No schema name available for renaming",
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    const newName = schemaName.endsWith("Schema") ? schemaName : `${schemaName}Schema`;
+    if (newName === schemaName) {
+      return {
+        success: false,
+        explanation: "Schema already matches naming convention",
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    const fixedCode = sourceCode.replace(new RegExp(`\\b${schemaName}\\b`, "g"), newName);
+    return {
+      success: true,
+      fixedCode,
+      explanation: `Renamed "${schemaName}" to "${newName}"`,
+      rule: violation.rule,
+      lineNumber: violation.lineNumber
+    };
+  }
+  fixRequireSafeParse(violation, sourceCode) {
+    const lines = sourceCode.split("\n");
+    const lineIndex = violation.lineNumber - 1;
+    const line = lines[lineIndex];
+    if (!line) {
+      return {
+        success: false,
+        explanation: `Line ${violation.lineNumber} not found`,
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    if (line.includes(".parse(") && !line.includes(".safeParse(")) {
+      lines[lineIndex] = line.replace(".parse(", ".safeParse(");
+      return {
+        success: true,
+        fixedCode: lines.join("\n"),
+        explanation: "Replaced .parse() with .safeParse() for safer error handling",
+        rule: violation.rule,
+        lineNumber: violation.lineNumber
+      };
+    }
+    return {
+      success: false,
+      explanation: "Could not find .parse() pattern to fix",
+      rule: violation.rule,
+      lineNumber: violation.lineNumber
+    };
+  }
+};
+
+// src/governance-templates.ts
+var GOVERNANCE_TEMPLATES = [
+  {
+    name: "no-any-schemas",
+    description: "Disallow z.any(), yup.mixed() without constraints, and similar unrestricted types",
+    category: "security",
+    rule: (sourceFile, _config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const lines = text.split("\n");
+      const anyPatterns = [
+        /\bz\.any\(\)/,
+        /\byup\.mixed\(\)/,
+        /\bt\.any\b/,
+        /\bv\.any\(\)/,
+        /\bunknown\(\)/
+      ];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        for (const pattern of anyPatterns) {
+          if (pattern.test(line)) {
+            violations.push({
+              rule: "no-any-schemas",
+              message: "Unrestricted type (any/mixed/unknown) found. Use a specific type with constraints.",
+              filePath,
+              lineNumber: i + 1,
+              schemaName: "",
+              severity: "error",
+              fixable: false
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  },
+  {
+    name: "require-descriptions",
+    description: "All exported schemas must have .describe() for documentation",
+    category: "quality",
+    rule: (sourceFile, _config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/export\s+(const|let)\s+\w+.*=\s*(z\.|yup\.)/.test(line)) {
+          let fullStatement = line;
+          let j = i + 1;
+          while (j < lines.length && !lines[j]?.includes(";") && j < i + 10) {
+            fullStatement += lines[j] ?? "";
+            j++;
+          }
+          if (j < lines.length) fullStatement += lines[j] ?? "";
+          if (!fullStatement.includes(".describe(")) {
+            const nameMatch = line.match(/(?:const|let)\s+(\w+)/);
+            violations.push({
+              rule: "require-descriptions",
+              message: `Exported schema ${nameMatch?.[1] || "unknown"} should include .describe() for documentation.`,
+              filePath,
+              lineNumber: i + 1,
+              schemaName: nameMatch?.[1] || "",
+              severity: "warning",
+              fixable: true
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  },
+  {
+    name: "max-nesting-depth",
+    description: "Limit schema nesting depth to prevent TypeScript performance issues",
+    category: "performance",
+    rule: (sourceFile, config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const maxDepth = config.threshold || 5;
+      const lines = text.split("\n");
+      let currentDepth = 0;
+      let maxFoundDepth = 0;
+      let deepestLine = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        for (const char of line) {
+          if (char === "(" || char === "{" || char === "[") {
+            currentDepth++;
+            if (currentDepth > maxFoundDepth) {
+              maxFoundDepth = currentDepth;
+              deepestLine = i + 1;
+            }
+          }
+          if (char === ")" || char === "}" || char === "]") {
+            currentDepth = Math.max(0, currentDepth - 1);
+          }
+        }
+      }
+      if (maxFoundDepth > maxDepth) {
+        violations.push({
+          rule: "max-nesting-depth",
+          message: `Schema nesting depth ${maxFoundDepth} exceeds maximum of ${maxDepth}. Consider breaking into smaller schemas.`,
+          filePath,
+          lineNumber: deepestLine,
+          schemaName: "",
+          severity: "warning",
+          fixable: false
+        });
+      }
+      return violations;
+    }
+  },
+  {
+    name: "no-deprecated-methods",
+    description: "Flag usage of deprecated schema methods",
+    category: "quality",
+    rule: (sourceFile, _config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const lines = text.split("\n");
+      const deprecatedPatterns = [
+        {
+          pattern: /\.deepPartial\(\)/,
+          message: ".deepPartial() is removed in Zod v4. Use recursive .partial() instead."
+        },
+        {
+          pattern: /\.strip\(\)/,
+          message: ".strip() is deprecated. Use z.strictObject() or explicit stripping."
+        },
+        {
+          pattern: /z\.promise\(/,
+          message: "z.promise() is deprecated in Zod v4. Use native Promise types."
+        },
+        {
+          pattern: /z\.ostring\(\)/,
+          message: "z.ostring() is removed in Zod v4. Use z.string().optional()."
+        },
+        {
+          pattern: /z\.onumber\(\)/,
+          message: "z.onumber() is removed in Zod v4. Use z.number().optional()."
+        },
+        {
+          pattern: /z\.oboolean\(\)/,
+          message: "z.oboolean() is removed in Zod v4. Use z.boolean().optional()."
+        },
+        {
+          pattern: /z\.preprocess\(/,
+          message: "z.preprocess() is removed in Zod v4. Use z.coerce.* instead."
+        }
+      ];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        for (const { pattern, message } of deprecatedPatterns) {
+          if (pattern.test(line)) {
+            violations.push({
+              rule: "no-deprecated-methods",
+              message,
+              filePath,
+              lineNumber: i + 1,
+              schemaName: "",
+              severity: "warning",
+              fixable: false
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  },
+  {
+    name: "naming-convention",
+    description: "Enforce schema naming pattern (e.g., must end with Schema)",
+    category: "quality",
+    rule: (sourceFile, config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const lines = text.split("\n");
+      const pattern = new RegExp(config.pattern || ".*Schema$");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const match = line.match(
+          /(?:const|let)\s+(\w+)\s*=\s*(?:z\.|yup\.|Joi\.|t\.|v\.|type\(|object\(|string\()/
+        );
+        if (match?.[1] && !pattern.test(match[1])) {
+          violations.push({
+            rule: "naming-convention",
+            message: `Schema "${match[1]}" does not match naming pattern ${pattern.source}.`,
+            filePath,
+            lineNumber: i + 1,
+            schemaName: match[1],
+            severity: "warning",
+            fixable: false
+          });
+        }
+      }
+      return violations;
+    }
+  },
+  {
+    name: "require-max-length",
+    description: "String schemas must have .max() to prevent DoS via unbounded input",
+    category: "security",
+    rule: (sourceFile, _config) => {
+      const violations = [];
+      const text = sourceFile.getFullText();
+      const filePath = sourceFile.getFilePath();
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/z\.string\(\)/.test(line) && !line.includes(".max(") && !line.includes(".length(")) {
+          let fullChain = line;
+          let j = i + 1;
+          while (j < lines.length && j < i + 5 && /^\s*\./.test(lines[j] ?? "")) {
+            fullChain += lines[j] ?? "";
+            j++;
+          }
+          if (!fullChain.includes(".max(") && !fullChain.includes(".length(")) {
+            violations.push({
+              rule: "require-max-length",
+              message: "String schema should have .max() to prevent unbounded input (DoS protection).",
+              filePath,
+              lineNumber: i + 1,
+              schemaName: "",
+              severity: "warning",
+              fixable: true
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  }
+];
+function getGovernanceTemplate(name) {
+  return GOVERNANCE_TEMPLATES.find((t) => t.name === name);
+}
+function getGovernanceTemplatesByCategory(category) {
+  return GOVERNANCE_TEMPLATES.filter((t) => t.category === category);
+}
+function getGovernanceTemplateNames() {
+  return GOVERNANCE_TEMPLATES.map((t) => t.name);
+}
+
+// src/graph-exporter.ts
+var LIBRARY_COLORS = {
+  zod: "#3068B7",
+  yup: "#32CD32",
+  joi: "#FF6347",
+  "io-ts": "#9370DB",
+  valibot: "#FF8C00",
+  arktype: "#20B2AA",
+  superstruct: "#DAA520",
+  effect: "#6A5ACD"
+};
+var LIBRARY_MERMAID_STYLES = {
+  zod: "fill:#3068B7,color:#fff",
+  yup: "fill:#32CD32,color:#000",
+  joi: "fill:#FF6347,color:#fff",
+  "io-ts": "fill:#9370DB,color:#fff",
+  valibot: "fill:#FF8C00,color:#000",
+  arktype: "fill:#20B2AA,color:#fff",
+  superstruct: "fill:#DAA520,color:#000",
+  effect: "fill:#6A5ACD,color:#fff"
+};
+var GraphExporter = class {
+  /**
+   * Export dependency graph as DOT format for Graphviz.
+   */
+  exportDot(graph, options = {}) {
+    const lines = [];
+    lines.push("digraph SchemaShiftDependencies {");
+    lines.push("  rankdir=LR;");
+    lines.push('  node [shape=box, style=filled, fontname="monospace"];');
+    lines.push('  edge [color="#666666"];');
+    lines.push("");
+    const circularFiles = /* @__PURE__ */ new Set();
+    if (options.highlightCircular && graph.circularWarnings.length > 0) {
+      for (const warning of graph.circularWarnings) {
+        const match = warning.match(/Circular dependency: (.+)/);
+        if (match?.[1]) {
+          for (const part of match[1].split(" -> ")) {
+            for (const file of graph.sortedFiles) {
+              if (file.endsWith(part.trim()) || this.shortenPath(file) === part.trim()) {
+                circularFiles.add(file);
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const filePath of graph.sortedFiles) {
+      const meta = options.nodeMetadata?.get(filePath);
+      const library = meta?.library;
+      if (options.filterLibrary && library !== options.filterLibrary) continue;
+      const shortPath = this.shortenPath(filePath);
+      const nodeId = this.toNodeId(filePath);
+      const attrs = [];
+      attrs.push(`label="${shortPath}"`);
+      if (circularFiles.has(filePath)) {
+        attrs.push('color="#FF0000"');
+        attrs.push("penwidth=2");
+      }
+      if (options.colorByLibrary && library && LIBRARY_COLORS[library]) {
+        attrs.push(`fillcolor="${LIBRARY_COLORS[library]}"`);
+        attrs.push('fontcolor="white"');
+      } else {
+        attrs.push('fillcolor="#E8E8E8"');
+      }
+      if (meta?.schemaCount) {
+        attrs.push(`tooltip="${meta.schemaCount} schema(s)"`);
+      }
+      lines.push(`  ${nodeId} [${attrs.join(", ")}];`);
+    }
+    lines.push("");
+    const filterSet = options.filterLibrary ? new Set(
+      graph.sortedFiles.filter((f) => {
+        const meta = options.nodeMetadata?.get(f);
+        return meta?.library === options.filterLibrary;
+      })
+    ) : void 0;
+    for (const [file, deps] of graph.dependencies) {
+      if (filterSet && !filterSet.has(file)) continue;
+      const fromId = this.toNodeId(file);
+      for (const dep of deps) {
+        if (filterSet && !filterSet.has(dep)) continue;
+        const toId = this.toNodeId(dep);
+        const edgeAttrs = [];
+        if (options.highlightCircular && circularFiles.has(file) && circularFiles.has(dep)) {
+          edgeAttrs.push('color="#FF0000"');
+          edgeAttrs.push("penwidth=2");
+        }
+        lines.push(
+          `  ${fromId} -> ${toId}${edgeAttrs.length > 0 ? ` [${edgeAttrs.join(", ")}]` : ""};`
+        );
+      }
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  /**
+   * Export dependency graph as Mermaid diagram syntax.
+   */
+  exportMermaid(graph, options = {}) {
+    const lines = [];
+    lines.push("graph LR");
+    const styledNodes = /* @__PURE__ */ new Map();
+    for (const [file, deps] of graph.dependencies) {
+      const meta = options.nodeMetadata?.get(file);
+      if (options.filterLibrary && meta?.library !== options.filterLibrary) continue;
+      const fromId = this.toMermaidId(file);
+      const fromLabel = this.shortenPath(file);
+      if (meta?.library) {
+        styledNodes.set(fromId, meta.library);
+      }
+      if (deps.length === 0) {
+        lines.push(`  ${fromId}["${fromLabel}"]`);
+      }
+      for (const dep of deps) {
+        const depMeta = options.nodeMetadata?.get(dep);
+        if (options.filterLibrary && depMeta?.library !== options.filterLibrary) continue;
+        const toId = this.toMermaidId(dep);
+        const toLabel = this.shortenPath(dep);
+        if (depMeta?.library) {
+          styledNodes.set(toId, depMeta.library);
+        }
+        lines.push(`  ${fromId}["${fromLabel}"] --> ${toId}["${toLabel}"]`);
+      }
+    }
+    for (const file of graph.sortedFiles) {
+      const meta = options.nodeMetadata?.get(file);
+      if (options.filterLibrary && meta?.library !== options.filterLibrary) continue;
+      const id = this.toMermaidId(file);
+      if (!lines.some((l) => l.includes(id))) {
+        lines.push(`  ${id}["${this.shortenPath(file)}"]`);
+        if (meta?.library) {
+          styledNodes.set(id, meta.library);
+        }
+      }
+    }
+    if (options.colorByLibrary && styledNodes.size > 0) {
+      lines.push("");
+      const libraryGroups = /* @__PURE__ */ new Map();
+      for (const [nodeId, library] of styledNodes) {
+        const group = libraryGroups.get(library) ?? [];
+        group.push(nodeId);
+        libraryGroups.set(library, group);
+      }
+      for (const [library, nodeIds] of libraryGroups) {
+        const style = LIBRARY_MERMAID_STYLES[library];
+        if (style) {
+          for (const nodeId of nodeIds) {
+            lines.push(`  style ${nodeId} ${style}`);
+          }
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  shortenPath(filePath) {
+    const parts = filePath.split("/");
+    return parts.slice(-2).join("/");
+  }
+  toNodeId(filePath) {
+    return filePath.replace(/[^a-zA-Z0-9]/g, "_").replace(/^_+/, "").replace(/_+$/, "");
+  }
+  toMermaidId(filePath) {
+    return filePath.replace(/[^a-zA-Z0-9]/g, "_").replace(/^_+/, "n_").replace(/_+$/, "");
+  }
+};
+
 // src/incremental.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 var STATE_DIR = ".schemashift";
 var STATE_FILE = "incremental.json";
 var IncrementalTracker = class {
   stateDir;
   statePath;
   constructor(projectPath) {
-    this.stateDir = join6(projectPath, STATE_DIR);
-    this.statePath = join6(this.stateDir, STATE_FILE);
+    this.stateDir = join8(projectPath, STATE_DIR);
+    this.statePath = join8(this.stateDir, STATE_FILE);
   }
   start(files, from, to) {
     const state = {
@@ -2300,9 +3572,9 @@ var IncrementalTracker = class {
     this.saveState(state);
   }
   getState() {
-    if (!existsSync6(this.statePath)) return null;
+    if (!existsSync8(this.statePath)) return null;
     try {
-      return JSON.parse(readFileSync6(this.statePath, "utf-8"));
+      return JSON.parse(readFileSync8(this.statePath, "utf-8"));
     } catch {
       return null;
     }
@@ -2329,21 +3601,299 @@ var IncrementalTracker = class {
     };
   }
   clear() {
-    if (existsSync6(this.statePath)) {
+    if (existsSync8(this.statePath)) {
       unlinkSync(this.statePath);
     }
   }
   saveState(state) {
-    if (!existsSync6(this.stateDir)) {
-      mkdirSync2(this.stateDir, { recursive: true });
+    if (!existsSync8(this.stateDir)) {
+      mkdirSync4(this.stateDir, { recursive: true });
     }
-    writeFileSync2(this.statePath, JSON.stringify(state, null, 2));
+    writeFileSync4(this.statePath, JSON.stringify(state, null, 2));
+  }
+};
+
+// src/migration-templates.ts
+var BUILT_IN_TEMPLATES = [
+  {
+    name: "react-hook-form-yup-to-zod",
+    description: "Migrate React Hook Form project from Yup to Zod validation",
+    category: "form-migration",
+    migrationSteps: [{ from: "yup", to: "zod", description: "Convert Yup schemas to Zod schemas" }],
+    preChecks: [
+      { description: "Ensure @hookform/resolvers is installed" },
+      { description: "Check for .when() conditional validations that need manual review" }
+    ],
+    postSteps: [
+      {
+        description: "Update resolver imports: yupResolver \u2192 zodResolver",
+        command: void 0
+      },
+      {
+        description: "Run tests to verify form validation behavior",
+        command: "npm test"
+      },
+      {
+        description: "Remove Yup dependency if no longer used",
+        command: "npm uninstall yup"
+      }
+    ],
+    packageChanges: [
+      { action: "install", package: "zod", version: "^3.24.0" },
+      { action: "upgrade", package: "@hookform/resolvers", version: "latest" }
+    ],
+    recommendedFlags: ["--cross-file", "--scaffold-tests", "--verbose"],
+    estimatedEffort: "moderate"
+  },
+  {
+    name: "trpc-zod-v3-to-v4",
+    description: "Upgrade tRPC project from Zod v3 to Zod v4",
+    category: "framework-upgrade",
+    migrationSteps: [
+      { from: "zod-v3", to: "v4", description: "Upgrade Zod v3 schemas to v4 syntax" }
+    ],
+    preChecks: [
+      { description: "Check tRPC version \u2014 v11+ required for Zod v4 compatibility" },
+      { description: "Check zod-validation-error version \u2014 v5.0.0+ required" },
+      { description: "Run existing test suite to establish baseline", command: "npm test" }
+    ],
+    postSteps: [
+      {
+        description: "Update tRPC to v11 if not already",
+        command: "npm install @trpc/server@latest @trpc/client@latest"
+      },
+      {
+        description: "Update zod-validation-error if used",
+        command: "npm install zod-validation-error@^5.0.0"
+      },
+      { description: "Review TODO(schemashift) comments for manual fixes" },
+      { description: "Run tests to verify tRPC router behavior", command: "npm test" }
+    ],
+    packageChanges: [
+      { action: "upgrade", package: "zod", version: "^3.25.0" },
+      { action: "upgrade", package: "@trpc/server", version: "^11.0.0" }
+    ],
+    recommendedFlags: ["--compat-check", "--scaffold-tests", "--verbose"],
+    estimatedEffort: "high"
+  },
+  {
+    name: "express-joi-to-zod",
+    description: "Migrate Express.js API validators from Joi to Zod",
+    category: "library-switch",
+    migrationSteps: [{ from: "joi", to: "zod", description: "Convert Joi schemas to Zod schemas" }],
+    preChecks: [
+      { description: "Identify middleware using Joi validation" },
+      { description: "Check for Joi.extend() custom validators that need manual migration" }
+    ],
+    postSteps: [
+      { description: "Update Express middleware to use Zod schemas" },
+      { description: "Replace celebrate/express-validation with custom Zod middleware" },
+      { description: "Run API integration tests", command: "npm test" },
+      { description: "Remove Joi dependency", command: "npm uninstall joi" }
+    ],
+    packageChanges: [
+      { action: "install", package: "zod", version: "^3.24.0" },
+      { action: "remove", package: "celebrate" }
+    ],
+    recommendedFlags: ["--cross-file", "--verbose"],
+    estimatedEffort: "moderate"
+  },
+  {
+    name: "nextjs-form-migration",
+    description: "Migrate Next.js form validation from Yup/Formik to Zod/React Hook Form",
+    category: "form-migration",
+    migrationSteps: [{ from: "yup", to: "zod", description: "Convert Yup schemas to Zod schemas" }],
+    preChecks: [
+      { description: "Identify all Formik form components" },
+      { description: "Check for server-side validation using Yup" },
+      { description: "Run existing tests to establish baseline", command: "npm test" }
+    ],
+    postSteps: [
+      { description: "Replace Formik with React Hook Form + zodResolver" },
+      { description: "Update server actions to use Zod for validation" },
+      {
+        description: "Install next-safe-action if using server actions",
+        command: "npm install next-safe-action"
+      },
+      { description: "Run full test suite", command: "npm test" }
+    ],
+    packageChanges: [
+      { action: "install", package: "zod", version: "^3.24.0" },
+      { action: "install", package: "react-hook-form", version: "^7.0.0" },
+      { action: "install", package: "@hookform/resolvers", version: "latest" }
+    ],
+    recommendedFlags: ["--cross-file", "--scaffold-tests"],
+    estimatedEffort: "high"
+  },
+  {
+    name: "monorepo-staged-migration",
+    description: "Phased monorepo migration with incremental tracking",
+    category: "monorepo",
+    migrationSteps: [
+      { from: "yup", to: "zod", description: "Convert shared packages first, then applications" }
+    ],
+    preChecks: [
+      { description: "Analyze monorepo workspace structure" },
+      { description: "Identify shared schema packages used by multiple apps" },
+      { description: "Ensure all packages build successfully", command: "npm run build" }
+    ],
+    postSteps: [
+      { description: "Run incremental migration starting with leaf packages" },
+      { description: "Build all packages after each batch", command: "npm run build" },
+      { description: "Run full test suite", command: "npm test" },
+      { description: "Review cross-package type compatibility" }
+    ],
+    packageChanges: [],
+    recommendedFlags: ["--cross-file", "--incremental", "--compat-check", "--audit"],
+    estimatedEffort: "high"
+  }
+];
+function getMigrationTemplate(name) {
+  return BUILT_IN_TEMPLATES.find((t) => t.name === name);
+}
+function getMigrationTemplateNames() {
+  return BUILT_IN_TEMPLATES.map((t) => t.name);
+}
+function getMigrationTemplatesByCategory(category) {
+  return BUILT_IN_TEMPLATES.filter((t) => t.category === category);
+}
+function getAllMigrationTemplates() {
+  return [...BUILT_IN_TEMPLATES];
+}
+function validateMigrationTemplate(template) {
+  const errors = [];
+  if (!template.name || template.name.trim().length === 0) {
+    errors.push("Template name is required");
+  }
+  if (!template.description || template.description.trim().length === 0) {
+    errors.push("Template description is required");
+  }
+  if (!template.migrationSteps || template.migrationSteps.length === 0) {
+    errors.push("At least one migration step is required");
+  }
+  for (const step of template.migrationSteps ?? []) {
+    if (!step.from || !step.to) {
+      errors.push(`Migration step must have from and to: ${JSON.stringify(step)}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/notifications.ts
+async function computeSignature(payload, secret) {
+  const { createHmac } = await import("crypto");
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+var WebhookNotifier = class {
+  webhooks;
+  constructor(webhooks) {
+    this.webhooks = webhooks;
+  }
+  /**
+   * Create a migration event with current timestamp.
+   */
+  createEvent(type, details, project) {
+    return {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      project,
+      details
+    };
+  }
+  /**
+   * Send an event to all matching webhooks.
+   */
+  async send(event) {
+    const results = [];
+    for (const webhook of this.webhooks) {
+      if (webhook.events && !webhook.events.includes(event.type)) {
+        continue;
+      }
+      const result = await this.sendToWebhook(webhook, event);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Send event to a single webhook endpoint.
+   */
+  async sendToWebhook(webhook, event) {
+    const payload = JSON.stringify(event);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "SchemaShift-Webhook/1.0",
+      ...webhook.headers
+    };
+    if (webhook.secret) {
+      const signature = await computeSignature(payload, webhook.secret);
+      headers["X-SchemaShift-Signature"] = `sha256=${signature}`;
+    }
+    try {
+      const response = await fetch(webhook.url, {
+        method: "POST",
+        headers,
+        body: payload
+      });
+      return {
+        success: response.ok,
+        statusCode: response.status,
+        error: response.ok ? void 0 : `HTTP ${response.status}: ${response.statusText}`
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Convenience: send a migration_started event.
+   */
+  async notifyMigrationStarted(from, to, fileCount, project) {
+    const event = this.createEvent("migration_started", { from, to, fileCount }, project);
+    return this.send(event);
+  }
+  /**
+   * Convenience: send a migration_completed event.
+   */
+  async notifyMigrationCompleted(from, to, fileCount, warningCount, project) {
+    const event = this.createEvent(
+      "migration_completed",
+      { from, to, fileCount, warningCount },
+      project
+    );
+    return this.send(event);
+  }
+  /**
+   * Convenience: send a migration_failed event.
+   */
+  async notifyMigrationFailed(from, to, error, project) {
+    const event = this.createEvent("migration_failed", { from, to, error }, project);
+    return this.send(event);
+  }
+  /**
+   * Convenience: send a governance_violation event.
+   */
+  async notifyGovernanceViolation(violationCount, rules, project) {
+    const event = this.createEvent("governance_violation", { violationCount, rules }, project);
+    return this.send(event);
+  }
+  /**
+   * Convenience: send a drift_detected event.
+   */
+  async notifyDriftDetected(modifiedFiles, addedFiles, removedFiles, project) {
+    const event = this.createEvent(
+      "drift_detected",
+      { modifiedFiles, addedFiles, removedFiles },
+      project
+    );
+    return this.send(event);
   }
 };
 
 // src/package-updater.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 var TARGET_VERSIONS = {
   "yup->zod": { zod: "^3.24.0" },
   "joi->zod": { zod: "^3.24.0" },
@@ -2364,14 +3914,14 @@ var PackageUpdater = class {
     const add = {};
     const remove = [];
     const warnings = [];
-    const pkgPath = join7(projectPath, "package.json");
-    if (!existsSync7(pkgPath)) {
+    const pkgPath = join9(projectPath, "package.json");
+    if (!existsSync9(pkgPath)) {
       warnings.push("No package.json found. Cannot plan dependency updates.");
       return { add, remove, warnings };
     }
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+      pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     } catch {
       warnings.push("Could not parse package.json.");
       return { add, remove, warnings };
@@ -2401,9 +3951,9 @@ var PackageUpdater = class {
     return { add, remove, warnings };
   }
   apply(projectPath, plan) {
-    const pkgPath = join7(projectPath, "package.json");
-    if (!existsSync7(pkgPath)) return;
-    const pkgText = readFileSync7(pkgPath, "utf-8");
+    const pkgPath = join9(projectPath, "package.json");
+    if (!existsSync9(pkgPath)) return;
+    const pkgText = readFileSync9(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgText);
     if (!pkg.dependencies) pkg.dependencies = {};
     for (const [name, version] of Object.entries(plan.add)) {
@@ -2413,7 +3963,7 @@ var PackageUpdater = class {
         pkg.dependencies[name] = version;
       }
     }
-    writeFileSync3(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    writeFileSync5(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
   }
 };
@@ -2585,8 +4135,8 @@ var PluginLoader = class {
 };
 
 // src/standard-schema.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
 var STANDARD_SCHEMA_LIBRARIES = {
   zod: { minMajor: 3, minMinor: 23 },
   // Zod v3.23+ and v4+
@@ -2615,13 +4165,13 @@ function isVersionCompatible(version, minMajor, minMinor) {
   return false;
 }
 function detectStandardSchema(projectPath) {
-  const pkgPath = join8(projectPath, "package.json");
-  if (!existsSync8(pkgPath)) {
+  const pkgPath = join10(projectPath, "package.json");
+  if (!existsSync10(pkgPath)) {
     return { detected: false, compatibleLibraries: [], recommendation: "", interopTools: [] };
   }
   let allDeps = {};
   try {
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return { detected: false, compatibleLibraries: [], recommendation: "", interopTools: [] };
@@ -2660,6 +4210,105 @@ function detectStandardSchema(projectPath) {
   return { detected, compatibleLibraries, recommendation, adoptionPath, interopTools };
 }
 
+// src/standard-schema-advisor.ts
+var STANDARD_SCHEMA_LIBS = /* @__PURE__ */ new Set(["zod", "valibot", "arktype"]);
+var StandardSchemaAdvisor = class {
+  /**
+   * Check if a schema library supports Standard Schema.
+   */
+  supportsStandardSchema(library) {
+    return STANDARD_SCHEMA_LIBS.has(library);
+  }
+  /**
+   * Generate advisory for a given migration path.
+   */
+  advise(from, to) {
+    const fromSupports = this.supportsStandardSchema(from);
+    const toSupports = this.supportsStandardSchema(to);
+    if (!fromSupports && !toSupports) {
+      return {
+        shouldConsiderAdapter: false,
+        reason: `Neither ${from} nor ${to} supports Standard Schema. Full migration is recommended.`,
+        migrationAdvantages: [
+          "Complete type safety with target library",
+          "Access to target library ecosystem",
+          "No runtime adapter overhead"
+        ],
+        adapterAdvantages: [],
+        recommendation: "migrate"
+      };
+    }
+    if (fromSupports && toSupports) {
+      return {
+        shouldConsiderAdapter: true,
+        reason: `Both ${from} and ${to} support Standard Schema 1.0. You may be able to use adapters for ecosystem tools (tRPC, TanStack Form, etc.) instead of migrating all schemas.`,
+        adapterExample: this.generateAdapterExample(from, to),
+        migrationAdvantages: [
+          "Full target library API and ergonomics",
+          "Consistent codebase (single library)",
+          "Better IDE support for one library",
+          "Smaller bundle (avoid loading two libraries)"
+        ],
+        adapterAdvantages: [
+          "No code changes needed for existing schemas",
+          "Gradual migration possible",
+          "Ecosystem tools work with both libraries via Standard Schema",
+          "Lower risk \u2014 existing validation behavior preserved"
+        ],
+        recommendation: "either"
+      };
+    }
+    if (toSupports && !fromSupports) {
+      return {
+        shouldConsiderAdapter: false,
+        reason: `${from} does not support Standard Schema, but ${to} does. Migrating to ${to} gives you Standard Schema interoperability.`,
+        migrationAdvantages: [
+          "Standard Schema interoperability with ecosystem tools",
+          "Future-proof validation layer",
+          `Access to ${to} API and type inference`
+        ],
+        adapterAdvantages: [],
+        recommendation: "migrate"
+      };
+    }
+    return {
+      shouldConsiderAdapter: false,
+      reason: `${from} supports Standard Schema but ${to} does not. Consider if you need the specific features of ${to} that justify losing Standard Schema interoperability.`,
+      migrationAdvantages: [`Access to ${to}-specific features`],
+      adapterAdvantages: [`Keeping ${from} preserves Standard Schema interoperability`],
+      recommendation: "migrate"
+    };
+  }
+  /**
+   * Analyze a project and provide advisory based on detected libraries.
+   */
+  adviseFromProject(projectPath, from, to) {
+    const projectInfo = detectStandardSchema(projectPath);
+    const advisory = this.advise(from, to);
+    return { ...advisory, projectInfo };
+  }
+  generateAdapterExample(from, to) {
+    return [
+      `// Instead of migrating all ${from} schemas to ${to},`,
+      `// you can use Standard Schema adapters for ecosystem tools:`,
+      `//`,
+      `// Example with tRPC (v11+):`,
+      `// tRPC accepts any Standard Schema-compatible schema.`,
+      `// Both ${from} and ${to} schemas work without conversion:`,
+      `//`,
+      `// import { ${from}Schema } from './existing-${from}-schemas';`,
+      `// import { ${to}Schema } from './new-${to}-schemas';`,
+      `//`,
+      `// const router = t.router({`,
+      `//   // Works with ${from} schema (Standard Schema compatible)`,
+      `//   getUser: t.procedure.input(${from}Schema).query(...)`,
+      `//   // Also works with ${to} schema`,
+      `//   createUser: t.procedure.input(${to}Schema).mutation(...)`,
+      `// });`
+    ].join("\n");
+  }
+};
+
 // src/test-scaffolder.ts
 var TestScaffolder = class {
   scaffold(sourceFiles, from, to) {
@@ -2953,14 +4602,19 @@ var TypeDedupDetector = class {
   }
 };
 export {
+  ApprovalManager,
   BehavioralWarningAnalyzer,
   BundleEstimator,
   CompatibilityAnalyzer,
   ComplexityEstimator,
   DetailedAnalyzer,
+  DriftDetector,
   EcosystemAnalyzer,
   FormResolverMigrator,
+  GOVERNANCE_TEMPLATES,
   GovernanceEngine,
+  GovernanceFixer,
+  GraphExporter,
   IncrementalTracker,
   MigrationAuditLog,
   MigrationChain,
@@ -2970,21 +4624,37 @@ export {
   PluginLoader,
   SchemaAnalyzer,
   SchemaDependencyResolver,
+  StandardSchemaAdvisor,
   TestScaffolder,
   TransformEngine,
   TypeDedupDetector,
+  WebhookNotifier,
   buildCallChain,
   computeParallelBatches,
+  conditionalValidation,
+  dependentFields,
   detectFormLibraries,
   detectSchemaLibrary,
   detectStandardSchema,
+  getAllMigrationTemplates,
+  getGovernanceTemplate,
+  getGovernanceTemplateNames,
+  getGovernanceTemplatesByCategory,
+  getMigrationTemplate,
+  getMigrationTemplateNames,
+  getMigrationTemplatesByCategory,
   isInsideComment,
   isInsideStringLiteral,
   loadConfig,
+  mutuallyExclusive,
   parseCallChain,
+  requireIf,
+  requireOneOf,
   shouldSuppressWarning,
   startsWithBase,
+  suggestCrossFieldPattern,
   transformMethodChain,
-  validateConfig
+  validateConfig,
+  validateMigrationTemplate
 };
 //# sourceMappingURL=index.js.map