@schemashift/core 0.10.0 → 0.12.0

package/dist/index.js

@@ -133,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) {
@@ -269,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;
@@ -278,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.
@@ -315,11 +419,11 @@ var MigrationAuditLog = class {
    * 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: [] };
       }
@@ -401,6 +505,88 @@ var MigrationAuditLog = class {
   clear() {
     this.write({ version: AUDIT_VERSION, entries: [] });
   }
+  /**
+   * Export a compliance report in SOC2 or HIPAA format.
+   */
+  exportComplianceReport(format) {
+    const log = this.read();
+    const summary = this.getSummary();
+    if (format === "soc2") {
+      return this.generateSoc2Report(log, summary);
+    }
+    return this.generateHipaaReport(log, summary);
+  }
+  generateSoc2Report(log, summary) {
+    const sections = [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    sections.push("# SOC2 Compliance Report \u2014 Schema Migration");
+    sections.push(`Generated: ${now}`);
+    sections.push("");
+    sections.push("## Change Control Summary");
+    sections.push(`- Total Migrations: ${summary.totalMigrations}`);
+    sections.push(`- Total Files Processed: ${summary.totalFiles}`);
+    sections.push(`- Successful: ${summary.successCount}`);
+    sections.push(`- Failed: ${summary.failureCount}`);
+    sections.push(`- Migration Paths: ${summary.migrationPaths.join(", ")}`);
+    sections.push("");
+    sections.push("## Change Control Entries");
+    for (const entry of log.entries) {
+      sections.push("");
+      sections.push(`### ${entry.filePath}`);
+      sections.push(`- Change ID: ${entry.migrationId}`);
+      sections.push(`- Timestamp: ${entry.timestamp}`);
+      sections.push(`- Action: ${entry.action}`);
+      sections.push(`- Migration: ${entry.from} \u2192 ${entry.to}`);
+      sections.push(`- Status: ${entry.success ? "Success" : "Failed"}`);
+      sections.push(`- Implementer: ${entry.user || "Unknown"}`);
+      sections.push(`- Before Hash: ${entry.beforeHash}`);
+      if (entry.afterHash) sections.push(`- After Hash: ${entry.afterHash}`);
+      sections.push(`- Warnings: ${entry.warningCount}`);
+      sections.push(`- Errors: ${entry.errorCount}`);
+      if (entry.riskScore !== void 0) sections.push(`- Risk Score: ${entry.riskScore}`);
+      if (entry.metadata?.ciProvider) sections.push(`- CI Provider: ${entry.metadata.ciProvider}`);
+      if (entry.metadata?.gitCommit) sections.push(`- Git Commit: ${entry.metadata.gitCommit}`);
+      if (entry.metadata?.gitBranch) sections.push(`- Git Branch: ${entry.metadata.gitBranch}`);
+    }
+    sections.push("");
+    sections.push("## Rollback Procedure");
+    sections.push("SchemaShift maintains automatic backups in `.schemashift/backups/`.");
+    sections.push("Use `schemashift rollback [backupId]` to restore files from any backup.");
+    sections.push("");
+    return sections.join("\n");
+  }
+  generateHipaaReport(log, summary) {
+    const sections = [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    sections.push("# HIPAA Compliance Audit Trail \u2014 Schema Migration");
+    sections.push(`Generated: ${now}`);
+    sections.push("");
+    sections.push("## Data Transformation Summary");
+    sections.push(`- Total Transformations: ${summary.totalFiles}`);
+    sections.push(`- Successful: ${summary.successCount}`);
+    sections.push(`- Failed: ${summary.failureCount}`);
+    sections.push("");
+    sections.push("## Integrity Verification");
+    for (const entry of log.entries) {
+      sections.push("");
+      sections.push(`### ${entry.filePath}`);
+      sections.push(`- Timestamp: ${entry.timestamp}`);
+      sections.push(`- User: ${entry.user || "Unknown"}`);
+      sections.push(`- Action: ${entry.action} (${entry.from} \u2192 ${entry.to})`);
+      sections.push(`- Integrity Before: SHA256:${entry.beforeHash}`);
+      if (entry.afterHash) sections.push(`- Integrity After: SHA256:${entry.afterHash}`);
+      sections.push(`- Status: ${entry.success ? "Completed" : "Failed"}`);
+      if (entry.metadata?.hostname) sections.push(`- Host: ${entry.metadata.hostname}`);
+      if (entry.metadata?.nodeVersion)
+        sections.push(`- Runtime: Node.js ${entry.metadata.nodeVersion}`);
+    }
+    sections.push("");
+    sections.push("## Access Control");
+    const users = [...new Set(log.entries.map((e) => e.user).filter(Boolean))];
+    sections.push(`- Users Who Performed Migrations: ${users.join(", ") || "Unknown"}`);
+    sections.push("");
+    return sections.join("\n");
+  }
   collectMetadata() {
     return {
       hostname: process.env.HOSTNAME || void 0,
@@ -412,10 +598,10 @@ var MigrationAuditLog = class {
     };
   }
   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);
@@ -848,12 +1034,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
   {
@@ -1108,6 +1294,72 @@ var ECOSYSTEM_RULES = [
       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",
@@ -1185,13 +1437,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 };
@@ -1312,10 +1564,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) {
@@ -1467,6 +1719,25 @@ var ComplexityEstimator = class {
       riskAreas
     };
   }
+  estimateDuration(estimate) {
+    const EFFORT_RANGES = {
+      trivial: { label: "1\u20135 minutes", range: [1, 5] },
+      low: { label: "5\u201315 minutes", range: [5, 15] },
+      moderate: { label: "15\u201345 minutes", range: [15, 45] },
+      high: { label: "1\u20133 hours", range: [60, 180] },
+      extreme: { label: "3\u20138 hours", range: [180, 480] }
+    };
+    const base = EFFORT_RANGES[estimate.effort];
+    const fileMultiplier = Math.max(1, Math.log2(estimate.totalFiles + 1));
+    const low = Math.round(base.range[0] * fileMultiplier);
+    const high = Math.round(base.range[1] * fileMultiplier);
+    if (high >= 120) {
+      const lowHours = Math.round(low / 60 * 10) / 10;
+      const highHours = Math.round(high / 60 * 10) / 10;
+      return { label: `${lowHours}\u2013${highHours} hours`, rangeMinutes: [low, high] };
+    }
+    return { label: `${low}\u2013${high} minutes`, rangeMinutes: [low, high] };
+  }
   calculateEffort(totalSchemas, advancedCount, hasDeepDU) {
     if (totalSchemas >= 500 && hasDeepDU) return "extreme";
     if (totalSchemas >= 200 || advancedCount >= 20) return "high";
@@ -1536,9 +1807,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);
@@ -1665,38 +2042,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;
@@ -1711,10 +2088,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);
@@ -1758,14 +2135,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;
         }
@@ -1784,7 +2161,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")) {
@@ -1810,13 +2187,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 {
@@ -1830,8 +2207,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;
@@ -1896,10 +2273,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,
@@ -2074,8 +2451,8 @@ var DetailedAnalyzer = class {
 
 // src/drift-detector.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6, relative } from "path";
+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;
@@ -2083,8 +2460,8 @@ var DriftDetector = class {
   snapshotDir;
   snapshotPath;
   constructor(projectPath) {
-    this.snapshotDir = join6(projectPath, SNAPSHOT_DIR);
-    this.snapshotPath = join6(this.snapshotDir, SNAPSHOT_FILE);
+    this.snapshotDir = join7(projectPath, SNAPSHOT_DIR);
+    this.snapshotPath = join7(this.snapshotDir, SNAPSHOT_FILE);
   }
   /**
    * Take a snapshot of the current schema state
@@ -2092,8 +2469,8 @@ var DriftDetector = class {
   snapshot(files, projectPath) {
     const schemas = [];
     for (const filePath of files) {
-      if (!existsSync6(filePath)) continue;
-      const content = readFileSync6(filePath, "utf-8");
+      if (!existsSync7(filePath)) continue;
+      const content = readFileSync7(filePath, "utf-8");
       const library = this.detectLibraryFromContent(content);
       if (library === "unknown") continue;
       const schemaNames = this.extractSchemaNames(content);
@@ -2117,20 +2494,20 @@ var DriftDetector = class {
    * Save a snapshot to disk
    */
   saveSnapshot(snapshot) {
-    if (!existsSync6(this.snapshotDir)) {
-      mkdirSync2(this.snapshotDir, { recursive: true });
+    if (!existsSync7(this.snapshotDir)) {
+      mkdirSync3(this.snapshotDir, { recursive: true });
     }
-    writeFileSync2(this.snapshotPath, JSON.stringify(snapshot, null, 2));
+    writeFileSync3(this.snapshotPath, JSON.stringify(snapshot, null, 2));
   }
   /**
    * Load saved snapshot from disk
    */
   loadSnapshot() {
-    if (!existsSync6(this.snapshotPath)) {
+    if (!existsSync7(this.snapshotPath)) {
       return null;
     }
     try {
-      const content = readFileSync6(this.snapshotPath, "utf-8");
+      const content = readFileSync7(this.snapshotPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -2592,6 +2969,250 @@ 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 = [
   {
@@ -2840,17 +3461,184 @@ 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 existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } 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 = join7(projectPath, STATE_DIR);
-    this.statePath = join7(this.stateDir, STATE_FILE);
+    this.stateDir = join8(projectPath, STATE_DIR);
+    this.statePath = join8(this.stateDir, STATE_FILE);
   }
   start(files, from, to) {
     const state = {
@@ -2885,9 +3673,9 @@ var IncrementalTracker = class {
     this.saveState(state);
   }
   getState() {
-    if (!existsSync7(this.statePath)) return null;
+    if (!existsSync8(this.statePath)) return null;
     try {
-      return JSON.parse(readFileSync7(this.statePath, "utf-8"));
+      return JSON.parse(readFileSync8(this.statePath, "utf-8"));
     } catch {
       return null;
     }
@@ -2913,22 +3701,416 @@ var IncrementalTracker = class {
       percent
     };
   }
+  /**
+   * Get a canary batch — a percentage of remaining files, sorted simplest first.
+   * Used for phased rollouts where you migrate a small batch, verify, then continue.
+   */
+  getCanaryBatch(percent, fileSizes) {
+    const state = this.getState();
+    if (!state) return [];
+    const count = Math.max(1, Math.ceil(state.remainingFiles.length * (percent / 100)));
+    if (fileSizes) {
+      const sorted = [...state.remainingFiles].sort((a, b) => {
+        return (fileSizes.get(a) ?? 0) - (fileSizes.get(b) ?? 0);
+      });
+      return sorted.slice(0, count);
+    }
+    return state.remainingFiles.slice(0, count);
+  }
   clear() {
-    if (existsSync7(this.statePath)) {
+    if (existsSync8(this.statePath)) {
       unlinkSync(this.statePath);
     }
   }
   saveState(state) {
-    if (!existsSync7(this.stateDir)) {
-      mkdirSync3(this.stateDir, { recursive: true });
+    if (!existsSync8(this.stateDir)) {
+      mkdirSync4(this.stateDir, { recursive: true });
+    }
+    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;
+  }
+  /**
+   * Format event as Slack Block Kit message.
+   */
+  formatSlackPayload(event) {
+    const emoji = this.getEventEmoji(event.type);
+    const title = this.getEventTitle(event.type);
+    const details = event.details;
+    const blocks = [
+      {
+        type: "header",
+        text: { type: "plain_text", text: `${emoji} ${title}`, emoji: true }
+      },
+      {
+        type: "section",
+        fields: Object.entries(details).map(([key, value]) => ({
+          type: "mrkdwn",
+          text: `*${key}:* ${String(value)}`
+        }))
+      },
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: `SchemaShift | ${event.timestamp}${event.project ? ` | ${event.project}` : ""}`
+          }
+        ]
+      }
+    ];
+    return { blocks };
+  }
+  /**
+   * Format event as Microsoft Teams Adaptive Card.
+   */
+  formatTeamsPayload(event) {
+    const title = this.getEventTitle(event.type);
+    const details = event.details;
+    const facts = Object.entries(details).map(([key, value]) => ({
+      title: key,
+      value: String(value)
+    }));
+    return {
+      type: "message",
+      attachments: [
+        {
+          contentType: "application/vnd.microsoft.card.adaptive",
+          content: {
+            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+            type: "AdaptiveCard",
+            version: "1.4",
+            body: [
+              {
+                type: "TextBlock",
+                text: title,
+                weight: "Bolder",
+                size: "Medium"
+              },
+              {
+                type: "FactSet",
+                facts
+              },
+              {
+                type: "TextBlock",
+                text: `SchemaShift | ${event.timestamp}`,
+                isSubtle: true,
+                size: "Small"
+              }
+            ]
+          }
+        }
+      ]
+    };
+  }
+  getEventEmoji(type) {
+    const emojis = {
+      migration_started: "\u{1F504}",
+      migration_completed: "\u2705",
+      migration_failed: "\u274C",
+      governance_violation: "\u26A0\uFE0F",
+      drift_detected: "\u{1F50D}"
+    };
+    return emojis[type];
+  }
+  getEventTitle(type) {
+    const titles = {
+      migration_started: "Migration Started",
+      migration_completed: "Migration Completed",
+      migration_failed: "Migration Failed",
+      governance_violation: "Governance Violation",
+      drift_detected: "Schema Drift Detected"
+    };
+    return titles[type];
+  }
+  /**
+   * Send event to a single webhook endpoint.
+   */
+  async sendToWebhook(webhook, event) {
+    let payload;
+    if (webhook.type === "slack") {
+      payload = JSON.stringify(this.formatSlackPayload(event));
+    } else if (webhook.type === "teams") {
+      payload = JSON.stringify(this.formatTeamsPayload(event));
+    } else {
+      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}`;
     }
-    writeFileSync3(this.statePath, JSON.stringify(state, null, 2));
+    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 existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } 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" },
@@ -2949,14 +4131,14 @@ var PackageUpdater = class {
     const add = {};
     const remove = [];
     const warnings = [];
-    const pkgPath = join8(projectPath, "package.json");
-    if (!existsSync8(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(readFileSync8(pkgPath, "utf-8"));
+      pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     } catch {
       warnings.push("Could not parse package.json.");
       return { add, remove, warnings };
@@ -2986,9 +4168,9 @@ var PackageUpdater = class {
     return { add, remove, warnings };
   }
   apply(projectPath, plan) {
-    const pkgPath = join8(projectPath, "package.json");
-    if (!existsSync8(pkgPath)) return;
-    const pkgText = readFileSync8(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)) {
@@ -2998,7 +4180,7 @@ var PackageUpdater = class {
         pkg.dependencies[name] = version;
       }
     }
-    writeFileSync4(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    writeFileSync5(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
   }
 };
@@ -3169,9 +4351,164 @@ var PluginLoader = class {
   }
 };
 
+// src/schema-verifier.ts
+var PRIMITIVE_SAMPLES = {
+  string: [
+    { name: "empty string", input: "", expectedValid: true },
+    { name: "normal string", input: "hello world", expectedValid: true },
+    { name: "number as string", input: "12345", expectedValid: true },
+    { name: "null input", input: null, expectedValid: false },
+    { name: "number input", input: 42, expectedValid: false },
+    { name: "boolean input", input: true, expectedValid: false },
+    { name: "undefined input", input: void 0, expectedValid: false }
+  ],
+  number: [
+    { name: "zero", input: 0, expectedValid: true },
+    { name: "positive int", input: 42, expectedValid: true },
+    { name: "negative int", input: -1, expectedValid: true },
+    { name: "float", input: 3.14, expectedValid: true },
+    { name: "string input", input: "hello", expectedValid: false },
+    { name: "null input", input: null, expectedValid: false },
+    { name: "NaN input", input: Number.NaN, expectedValid: false }
+  ],
+  boolean: [
+    { name: "true", input: true, expectedValid: true },
+    { name: "false", input: false, expectedValid: true },
+    { name: "string input", input: "true", expectedValid: false },
+    { name: "number input", input: 1, expectedValid: false },
+    { name: "null input", input: null, expectedValid: false }
+  ],
+  date: [
+    { name: "valid date", input: /* @__PURE__ */ new Date("2024-01-01"), expectedValid: true },
+    { name: "string input", input: "2024-01-01", expectedValid: false },
+    { name: "null input", input: null, expectedValid: false }
+  ]
+};
+var EMAIL_SAMPLES = [
+  { name: "valid email", input: "test@example.com", expectedValid: true },
+  { name: "invalid email", input: "not-an-email", expectedValid: false },
+  { name: "empty string", input: "", expectedValid: false }
+];
+var URL_SAMPLES = [
+  { name: "valid url", input: "https://example.com", expectedValid: true },
+  { name: "invalid url", input: "not a url", expectedValid: false }
+];
+var UUID_SAMPLES = [
+  { name: "valid uuid", input: "550e8400-e29b-41d4-a716-446655440000", expectedValid: true },
+  { name: "invalid uuid", input: "not-a-uuid", expectedValid: false }
+];
+function extractSchemaNames(sourceText) {
+  const schemas = [];
+  const patterns = [
+    /(?:const|let|var)\s+(\w+)\s*=\s*(?:z\.|yup\.|Joi\.|v\.|t\.|S\.|type\(|object\(|string\()/g,
+    /export\s+(?:const|let|var)\s+(\w+)\s*=\s*(?:z\.|yup\.|Joi\.|v\.|t\.|S\.|type\(|object\(|string\()/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of sourceText.matchAll(pattern)) {
+      const name = match[1];
+      if (name && !schemas.includes(name)) {
+        schemas.push(name);
+      }
+    }
+  }
+  return schemas;
+}
+function generateSamples(sourceText, schemaName, maxSamples) {
+  const samples = [];
+  const schemaBlock = extractSchemaBlock(sourceText, schemaName);
+  if (!schemaBlock) return PRIMITIVE_SAMPLES.string?.slice(0, maxSamples) ?? [];
+  if (/\.email\s*\(/.test(schemaBlock)) {
+    samples.push(...EMAIL_SAMPLES);
+  }
+  if (/\.url\s*\(/.test(schemaBlock)) {
+    samples.push(...URL_SAMPLES);
+  }
+  if (/\.uuid\s*\(/.test(schemaBlock)) {
+    samples.push(...UUID_SAMPLES);
+  }
+  if (/string\s*\(/.test(schemaBlock)) {
+    samples.push(...PRIMITIVE_SAMPLES.string ?? []);
+  }
+  if (/number\s*\(/.test(schemaBlock) || /\.int\s*\(/.test(schemaBlock)) {
+    samples.push(...PRIMITIVE_SAMPLES.number ?? []);
+  }
+  if (/boolean\s*\(/.test(schemaBlock)) {
+    samples.push(...PRIMITIVE_SAMPLES.boolean ?? []);
+  }
+  if (/date\s*\(/.test(schemaBlock)) {
+    samples.push(...PRIMITIVE_SAMPLES.date ?? []);
+  }
+  if (/\.optional\s*\(/.test(schemaBlock) || /optional\s*\(/.test(schemaBlock)) {
+    samples.push({ name: "undefined (optional)", input: void 0, expectedValid: true });
+  }
+  if (/\.nullable\s*\(/.test(schemaBlock) || /nullable\s*\(/.test(schemaBlock)) {
+    samples.push({ name: "null (nullable)", input: null, expectedValid: true });
+  }
+  if (/\.min\s*\(\s*(\d+)/.test(schemaBlock)) {
+    const minMatch = schemaBlock.match(/\.min\s*\(\s*(\d+)/);
+    const minVal = minMatch ? Number.parseInt(minMatch[1] ?? "0", 10) : 0;
+    samples.push({
+      name: `below min (${minVal})`,
+      input: minVal > 0 ? "a".repeat(minVal - 1) : "",
+      expectedValid: false
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const s of samples) {
+    if (!seen.has(s.name)) {
+      seen.add(s.name);
+      unique.push(s);
+    }
+  }
+  return unique.slice(0, maxSamples);
+}
+function extractSchemaBlock(sourceText, schemaName) {
+  const escapedName = schemaName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:const|let|var|export\\s+const)\\s+${escapedName}\\s*=\\s*([\\s\\S]*?)(?:;\\s*$|;\\s*(?:const|let|var|export|function|class|type|interface))`,
+    "m"
+  );
+  const match = sourceText.match(pattern);
+  return match?.[1] ?? null;
+}
+function createVerificationReport(from, to, results) {
+  const totalSchemas = results.length;
+  const overallParityScore = totalSchemas > 0 ? results.reduce((sum, r) => sum + r.parityScore, 0) / totalSchemas : 100;
+  return {
+    from,
+    to,
+    totalSchemas,
+    results,
+    overallParityScore: Math.round(overallParityScore * 100) / 100,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatVerificationReport(report) {
+  const lines = [];
+  lines.push(`
+Schema Verification Report: ${report.from} \u2192 ${report.to}`);
+  lines.push("\u2500".repeat(50));
+  for (const result of report.results) {
+    const icon = result.parityScore === 100 ? "\u2713" : result.parityScore >= 80 ? "\u26A0" : "\u2717";
+    lines.push(
+      `  ${icon} ${result.schemaName} \u2014 ${result.parityScore}% parity (${result.matchingSamples}/${result.totalSamples} samples)`
+    );
+    for (const mismatch of result.mismatches) {
+      lines.push(
+        `    \u2514\u2500 ${mismatch.sampleName}: source=${mismatch.sourceResult.valid ? "valid" : "invalid"}, target=${mismatch.targetResult.valid ? "valid" : "invalid"}`
+      );
+    }
+  }
+  lines.push("\u2500".repeat(50));
+  lines.push(`Overall Parity: ${report.overallParityScore}%`);
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/standard-schema.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join9 } 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+
@@ -3200,13 +4537,13 @@ function isVersionCompatible(version, minMajor, minMinor) {
   return false;
 }
 function detectStandardSchema(projectPath) {
-  const pkgPath = join9(projectPath, "package.json");
-  if (!existsSync9(pkgPath)) {
+  const pkgPath = join10(projectPath, "package.json");
+  if (!existsSync10(pkgPath)) {
     return { detected: false, compatibleLibraries: [], recommendation: "", interopTools: [] };
   }
   let allDeps = {};
   try {
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return { detected: false, compatibleLibraries: [], recommendation: "", interopTools: [] };
@@ -3245,6 +4582,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) {
@@ -3538,6 +4974,7 @@ var TypeDedupDetector = class {
   }
 };
 export {
+  ApprovalManager,
   BehavioralWarningAnalyzer,
   BundleEstimator,
   CompatibilityAnalyzer,
@@ -3548,6 +4985,8 @@ export {
   FormResolverMigrator,
   GOVERNANCE_TEMPLATES,
   GovernanceEngine,
+  GovernanceFixer,
+  GraphExporter,
   IncrementalTracker,
   MigrationAuditLog,
   MigrationChain,
@@ -3557,24 +4996,41 @@ export {
   PluginLoader,
   SchemaAnalyzer,
   SchemaDependencyResolver,
+  StandardSchemaAdvisor,
   TestScaffolder,
   TransformEngine,
   TypeDedupDetector,
+  WebhookNotifier,
   buildCallChain,
   computeParallelBatches,
+  conditionalValidation,
+  createVerificationReport,
+  dependentFields,
   detectFormLibraries,
   detectSchemaLibrary,
   detectStandardSchema,
+  extractSchemaNames,
+  formatVerificationReport,
+  generateSamples,
+  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