pocketbase-zod-schema 0.1.2

package/dist/cli/migrate.js

@@ -0,0 +1,3353 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import * as path4 from 'path';
+import * as fs4 from 'fs';
+import { z } from 'zod';
+import ora from 'ora';
+
+// src/migration/errors.ts
+var MigrationError = class _MigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+    Object.setPrototypeOf(this, _MigrationError.prototype);
+  }
+};
+var SchemaParsingError = class _SchemaParsingError extends MigrationError {
+  filePath;
+  originalError;
+  constructor(message, filePath, originalError) {
+    super(message);
+    this.name = "SchemaParsingError";
+    this.filePath = filePath;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _SchemaParsingError.prototype);
+  }
+  /**
+   * Creates a formatted error message with file path and original error details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.filePath) {
+      parts.push(`
+File: ${this.filePath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var SnapshotError = class _SnapshotError extends MigrationError {
+  snapshotPath;
+  operation;
+  originalError;
+  constructor(message, snapshotPath, operation, originalError) {
+    super(message);
+    this.name = "SnapshotError";
+    this.snapshotPath = snapshotPath;
+    this.operation = operation;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _SnapshotError.prototype);
+  }
+  /**
+   * Creates a formatted error message with snapshot path and operation details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.snapshotPath) {
+      parts.push(`
+Snapshot: ${this.snapshotPath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var MigrationGenerationError = class _MigrationGenerationError extends MigrationError {
+  migrationPath;
+  originalError;
+  constructor(message, migrationPath, originalError) {
+    super(message);
+    this.name = "MigrationGenerationError";
+    this.migrationPath = migrationPath;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _MigrationGenerationError.prototype);
+  }
+  /**
+   * Creates a formatted error message with migration path and original error details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.migrationPath) {
+      parts.push(`
+Migration: ${this.migrationPath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var FileSystemError = class _FileSystemError extends MigrationError {
+  path;
+  operation;
+  code;
+  originalError;
+  constructor(message, path6, operation, code, originalError) {
+    super(message);
+    this.name = "FileSystemError";
+    this.path = path6;
+    this.operation = operation;
+    this.code = code;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _FileSystemError.prototype);
+  }
+  /**
+   * Creates a formatted error message with path, operation, and error code details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.path) {
+      parts.push(`
+Path: ${this.path}`);
+    }
+    if (this.code) {
+      parts.push(`
+Error Code: ${this.code}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var ConfigurationError = class _ConfigurationError extends MigrationError {
+  configPath;
+  invalidFields;
+  originalError;
+  constructor(message, configPath, invalidFields, originalError) {
+    super(message);
+    this.name = "ConfigurationError";
+    this.configPath = configPath;
+    this.invalidFields = invalidFields;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+  /**
+   * Creates a formatted error message with configuration details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.configPath) {
+      parts.push(`
+Configuration File: ${this.configPath}`);
+    }
+    if (this.invalidFields && this.invalidFields.length > 0) {
+      parts.push(`
+Invalid Fields: ${this.invalidFields.join(", ")}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+
+// src/schema/permission-templates.ts
+var PermissionTemplates = {
+  /**
+   * Public access - anyone can perform all operations
+   */
+  public: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: "",
+    updateRule: "",
+    deleteRule: ""
+  }),
+  /**
+   * Authenticated users only - requires valid authentication for all operations
+   */
+  authenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
+  /**
+   * Owner-only access - users can only manage their own records
+   * @param ownerField - Name of the relation field pointing to user (default: 'User')
+   */
+  ownerOnly: (ownerField = "User") => ({
+    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    createRule: '@request.auth.id != ""',
+    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
+  }),
+  /**
+   * Admin/superuser only access
+   * Assumes a 'role' field exists with 'admin' value
+   * @param roleField - Name of the role field (default: 'role')
+   */
+  adminOnly: (roleField = "role") => ({
+    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
+  }),
+  /**
+   * Public read, authenticated write
+   * Anyone can list/view, but only authenticated users can create/update/delete
+   */
+  readPublic: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
+  /**
+   * Locked access - only superusers can perform operations
+   * All rules are set to null (locked)
+   */
+  locked: () => ({
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  }),
+  /**
+   * Read-only authenticated - authenticated users can read, no write access
+   */
+  readOnlyAuthenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  })
+};
+function resolveTemplate(config) {
+  let baseRules;
+  switch (config.template) {
+    case "public":
+      baseRules = PermissionTemplates.public();
+      break;
+    case "authenticated":
+      baseRules = PermissionTemplates.authenticated();
+      break;
+    case "owner-only":
+      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
+      break;
+    case "admin-only":
+      baseRules = PermissionTemplates.adminOnly(config.roleField);
+      break;
+    case "read-public":
+      baseRules = PermissionTemplates.readPublic();
+      break;
+    case "custom":
+      baseRules = {};
+      break;
+    default: {
+      const _exhaustive = config.template;
+      throw new Error(`Unknown template type: ${_exhaustive}`);
+    }
+  }
+  return {
+    ...baseRules,
+    ...config.customRules
+  };
+}
+
+// src/migration/rule-validator.ts
+var RuleValidator = class {
+  fields;
+  collectionName;
+  isAuthCollection;
+  constructor(collectionName, fields, isAuthCollection2 = false) {
+    this.collectionName = collectionName;
+    this.fields = new Map(fields.map((f) => [f.name, f]));
+    this.isAuthCollection = isAuthCollection2;
+    this.addSystemFields();
+  }
+  /**
+   * Add system fields that are always available in PocketBase collections
+   * These fields are automatically added by PocketBase and can be referenced in rules
+   */
+  addSystemFields() {
+    const systemFields = [
+      { name: "id", type: "text", required: true, options: {} },
+      { name: "created", type: "date", required: true, options: {} },
+      { name: "updated", type: "date", required: true, options: {} },
+      { name: "collectionId", type: "text", required: true, options: {} },
+      { name: "collectionName", type: "text", required: true, options: {} }
+    ];
+    if (this.isAuthCollection) {
+      systemFields.push(
+        { name: "email", type: "email", required: true, options: {} },
+        { name: "emailVisibility", type: "bool", required: false, options: {} },
+        { name: "verified", type: "bool", required: false, options: {} },
+        { name: "tokenKey", type: "text", required: true, options: {} },
+        { name: "password", type: "text", required: true, options: {} }
+      );
+    }
+    for (const field of systemFields) {
+      if (!this.fields.has(field.name)) {
+        this.fields.set(field.name, field);
+      }
+    }
+  }
+  /**
+   * Validate a rule expression
+   *
+   * @param ruleType - The type of rule being validated
+   * @param expression - The rule expression to validate
+   * @returns Validation result with errors, warnings, and field references
+   */
+  validate(ruleType, expression) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      fieldReferences: []
+    };
+    if (expression === null) {
+      return result;
+    }
+    if (expression === "") {
+      result.warnings.push(`${ruleType} is public - anyone can perform this operation`);
+      return result;
+    }
+    if (ruleType === "manageRule" && !this.isAuthCollection) {
+      result.valid = false;
+      result.errors.push("manageRule is only valid for auth collections");
+      return result;
+    }
+    const fieldRefs = this.extractFieldReferences(expression);
+    result.fieldReferences = fieldRefs;
+    for (const fieldRef of fieldRefs) {
+      this.validateFieldReference(fieldRef, result);
+    }
+    this.validateRequestReferences(expression, result);
+    this.validateSyntax(expression, result);
+    return result;
+  }
+  /**
+   * Extract field references from expression
+   *
+   * Matches field names that are not @request references.
+   * Handles dot notation for relations: user.email, post.author.name
+   *
+   * @param expression - The rule expression
+   * @returns Array of unique field references
+   */
+  extractFieldReferences(expression) {
+    const refs = [];
+    let cleaned = expression.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''");
+    cleaned = cleaned.replace(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g, "");
+    const fieldPattern = /(?:^|[^@\w])([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)(?=[^a-zA-Z0-9_.]|$)/g;
+    let match;
+    while ((match = fieldPattern.exec(cleaned)) !== null) {
+      const ref = match[1];
+      if (!this.isKeyword(ref)) {
+        refs.push(ref);
+      }
+    }
+    return [...new Set(refs)];
+  }
+  /**
+   * Check if a word is a PocketBase keyword
+   *
+   * @param word - The word to check
+   * @returns True if the word is a keyword
+   */
+  isKeyword(word) {
+    const keywords = ["true", "false", "null", "AND", "OR", "NOT", "LIKE", "IN"];
+    return keywords.includes(word.toUpperCase());
+  }
+  /**
+   * Validate a field reference exists in schema
+   *
+   * Checks if the root field exists and validates relation chains.
+   * For nested references, warns about potential issues since we can't
+   * validate across collections without loading related schemas.
+   *
+   * @param fieldRef - The field reference to validate (e.g., "user" or "user.email")
+   * @param result - The validation result to update
+   */
+  validateFieldReference(fieldRef, result) {
+    const parts = fieldRef.split(".");
+    const rootField = parts[0];
+    if (!this.fields.has(rootField)) {
+      result.errors.push(`Field '${rootField}' does not exist in collection '${this.collectionName}'`);
+      result.valid = false;
+      return;
+    }
+    if (parts.length > 1) {
+      const field = this.fields.get(rootField);
+      if (field.type !== "relation") {
+        result.errors.push(`Field '${rootField}' is not a relation field, cannot access nested property '${parts[1]}'`);
+        result.valid = false;
+      } else {
+        result.warnings.push(
+          `Nested field reference '${fieldRef}' - ensure target collection has field '${parts.slice(1).join(".")}'`
+        );
+      }
+    }
+  }
+  /**
+   * Validate @request references
+   *
+   * Checks that @request references follow valid PocketBase patterns:
+   * - @request.auth.* - authenticated user data
+   * - @request.body.* - request body fields
+   * - @request.query.* - query parameters
+   * - @request.headers.* - request headers
+   * - @request.method - HTTP method
+   * - @request.context - execution context
+   *
+   * @param expression - The rule expression
+   * @param result - The validation result to update
+   */
+  validateRequestReferences(expression, result) {
+    const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
+    for (const ref of requestRefs) {
+      const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
+      if (!isValid) {
+        result.errors.push(`Invalid @request reference: '${ref}'`);
+        result.valid = false;
+      }
+    }
+  }
+  /**
+   * Validate basic syntax patterns
+   *
+   * Checks for:
+   * - Balanced parentheses
+   * - Common operator mistakes (== instead of =)
+   *
+   * @param expression - The rule expression
+   * @param result - The validation result to update
+   */
+  validateSyntax(expression, result) {
+    let parenCount = 0;
+    for (const char of expression) {
+      if (char === "(") parenCount++;
+      if (char === ")") parenCount--;
+      if (parenCount < 0) {
+        result.errors.push("Unbalanced parentheses in expression");
+        result.valid = false;
+        return;
+      }
+    }
+    if (parenCount !== 0) {
+      result.errors.push("Unbalanced parentheses in expression");
+      result.valid = false;
+    }
+    if (expression.includes("==")) {
+      result.warnings.push("Use '=' instead of '==' for equality comparison in PocketBase rules");
+    }
+  }
+};
+
+// src/migration/permission-analyzer.ts
+var PermissionAnalyzer = class {
+  /**
+   * Extract permission metadata from Zod schema description
+   *
+   * Zod schemas can have permission metadata attached via the describe() method.
+   * This method parses the description and extracts the permission configuration.
+   *
+   * @param schemaDescription - The Zod schema description string
+   * @returns Permission schema if found, null otherwise
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const permissions = analyzer.extractPermissions(schema.description);
+   * ```
+   */
+  extractPermissions(schemaDescription) {
+    if (!schemaDescription) {
+      return null;
+    }
+    try {
+      const metadata = JSON.parse(schemaDescription);
+      if (metadata.permissions) {
+        return metadata.permissions;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  /**
+   * Resolve template configuration to concrete rules
+   *
+   * Takes either a template configuration or a direct permission schema
+   * and returns a fully resolved permission schema with all rules defined.
+   *
+   * If the input is already a permission schema (has rule properties),
+   * it's returned as-is. Otherwise, the template is resolved using the
+   * template resolver.
+   *
+   * @param config - Template configuration or direct permission schema
+   * @returns Resolved permission schema
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   *
+   * // Resolve from template
+   * const permissions = analyzer.resolvePermissions({
+   *   template: 'owner-only',
+   *   ownerField: 'User'
+   * });
+   *
+   * // Or pass direct schema
+   * const permissions = analyzer.resolvePermissions({
+   *   listRule: '@request.auth.id != ""',
+   *   viewRule: '@request.auth.id != ""'
+   * });
+   * ```
+   */
+  resolvePermissions(config) {
+    if ("listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config) {
+      return config;
+    }
+    return resolveTemplate(config);
+  }
+  /**
+   * Validate all rules in a permission schema
+   *
+   * Validates each rule in the permission schema against the collection's
+   * field definitions. Returns a map of validation results keyed by rule type.
+   *
+   * Only validates rules that are defined (not undefined). Undefined rules
+   * are treated as null (locked) by default.
+   *
+   * @param collectionName - Name of the collection being validated
+   * @param permissions - Permission schema to validate
+   * @param fields - Collection field definitions
+   * @param isAuthCollection - Whether this is an auth collection (allows manageRule)
+   * @returns Map of validation results by rule type
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const results = analyzer.validatePermissions(
+   *   'posts',
+   *   { listRule: '@request.auth.id != ""', viewRule: 'author = @request.auth.id' },
+   *   fields,
+   *   false
+   * );
+   *
+   * for (const [ruleType, result] of results) {
+   *   if (!result.valid) {
+   *     console.error(`${ruleType} validation failed:`, result.errors);
+   *   }
+   * }
+   * ```
+   */
+  validatePermissions(collectionName, permissions, fields, isAuthCollection2 = false) {
+    const validator = new RuleValidator(collectionName, fields, isAuthCollection2);
+    const results = /* @__PURE__ */ new Map();
+    const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
+    if (isAuthCollection2) {
+      ruleTypes.push("manageRule");
+    }
+    for (const ruleType of ruleTypes) {
+      const expression = permissions[ruleType];
+      if (expression !== void 0) {
+        results.set(ruleType, validator.validate(ruleType, expression));
+      }
+    }
+    return results;
+  }
+  /**
+   * Merge permissions with defaults
+   *
+   * Ensures all rule types have a defined value. Undefined rules are set
+   * to null (locked to superusers only), which is the PocketBase default.
+   *
+   * This is useful when generating migrations to ensure all rules are
+   * explicitly set in the collection configuration.
+   *
+   * @param permissions - Permission schema (may have undefined rules)
+   * @returns Permission schema with all rules defined (null if not specified)
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const merged = analyzer.mergeWithDefaults({
+   *   listRule: '@request.auth.id != ""'
+   *   // other rules undefined
+   * });
+   *
+   * // Result:
+   * // {
+   * //   listRule: '@request.auth.id != ""',
+   * //   viewRule: null,
+   * //   createRule: null,
+   * //   updateRule: null,
+   * //   deleteRule: null,
+   * //   manageRule: null
+   * // }
+   * ```
+   */
+  mergeWithDefaults(permissions) {
+    return {
+      listRule: permissions.listRule ?? null,
+      viewRule: permissions.viewRule ?? null,
+      createRule: permissions.createRule ?? null,
+      updateRule: permissions.updateRule ?? null,
+      deleteRule: permissions.deleteRule ?? null,
+      manageRule: permissions.manageRule ?? null
+    };
+  }
+};
+
+// src/migration/utils/pluralize.ts
+var SPECIAL_CASES = {
+  // Common irregular plurals
+  person: "people",
+  Person: "People",
+  child: "children",
+  Child: "Children",
+  man: "men",
+  Man: "Men",
+  woman: "women",
+  Woman: "Women",
+  tooth: "teeth",
+  Tooth: "Teeth",
+  foot: "feet",
+  Foot: "Feet",
+  mouse: "mice",
+  Mouse: "Mice",
+  goose: "geese",
+  Goose: "Geese",
+  // Words ending in -y
+  category: "categories",
+  Category: "Categories",
+  company: "companies",
+  Company: "Companies",
+  city: "cities",
+  City: "Cities",
+  country: "countries",
+  Country: "Countries",
+  story: "stories",
+  Story: "Stories",
+  party: "parties",
+  Party: "Parties",
+  family: "families",
+  Family: "Families",
+  activity: "activities",
+  Activity: "Activities",
+  priority: "priorities",
+  Priority: "Priorities",
+  // Words ending in -f or -fe
+  life: "lives",
+  Life: "Lives",
+  wife: "wives",
+  Wife: "Wives",
+  knife: "knives",
+  Knife: "Knives",
+  leaf: "leaves",
+  Leaf: "Leaves",
+  shelf: "shelves",
+  Shelf: "Shelves",
+  half: "halves",
+  Half: "Halves",
+  // Words ending in -is
+  analysis: "analyses",
+  Analysis: "Analyses",
+  basis: "bases",
+  Basis: "Bases",
+  crisis: "crises",
+  Crisis: "Crises",
+  thesis: "theses",
+  Thesis: "Theses",
+  // Words ending in -us
+  cactus: "cacti",
+  Cactus: "Cacti",
+  focus: "foci",
+  Focus: "Foci",
+  fungus: "fungi",
+  Fungus: "Fungi",
+  nucleus: "nuclei",
+  Nucleus: "Nuclei",
+  radius: "radii",
+  Radius: "Radii",
+  // Words ending in -on
+  phenomenon: "phenomena",
+  Phenomenon: "Phenomena",
+  criterion: "criteria",
+  Criterion: "Criteria",
+  // Words ending in -um
+  datum: "data",
+  Datum: "Data",
+  medium: "media",
+  Medium: "Media",
+  curriculum: "curricula",
+  Curriculum: "Curricula",
+  // Unchanged plurals
+  sheep: "sheep",
+  Sheep: "Sheep",
+  deer: "deer",
+  Deer: "Deer",
+  fish: "fish",
+  Fish: "Fish",
+  species: "species",
+  Species: "Species",
+  series: "series",
+  Series: "Series"
+};
+function pluralize(singular) {
+  if (SPECIAL_CASES[singular]) {
+    return SPECIAL_CASES[singular];
+  }
+  if (singular.length > 3 && singular.endsWith("s") && !singular.endsWith("ss")) {
+    return singular;
+  }
+  const lowerSingular = singular.toLowerCase();
+  let plural;
+  if (/(?:s|ss|sh|ch|x|z)$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/[^aeiou]y$/.test(lowerSingular)) {
+    plural = singular.slice(0, -1) + "ies";
+  } else if (/[^aeiou]o$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/fe?$/.test(lowerSingular)) {
+    if (lowerSingular.endsWith("fe")) {
+      plural = singular.slice(0, -2) + "ves";
+    } else {
+      plural = singular.slice(0, -1) + "ves";
+    }
+  } else {
+    plural = singular + "s";
+  }
+  return plural;
+}
+function toCollectionName(entityName) {
+  return pluralize(entityName);
+}
+function isSingleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof z.ZodString)) {
+    return false;
+  }
+  const startsWithUppercase = /^[A-Z]/.test(fieldName);
+  const commonStringFields = ["Title", "Name", "Description", "Content", "Summary", "Status", "Type"];
+  const isCommonField = commonStringFields.includes(fieldName);
+  return startsWithUppercase && !isCommonField;
+}
+function isMultipleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof z.ZodArray)) {
+    return false;
+  }
+  const elementType = unwrappedType._def.type;
+  if (!(elementType instanceof z.ZodString)) {
+    return false;
+  }
+  const hasUppercase = /[A-Z]/.test(fieldName);
+  return hasUppercase;
+}
+function resolveTargetCollection(fieldName) {
+  const matches = fieldName.match(/[A-Z][a-z]+/g);
+  if (!matches || matches.length === 0) {
+    return pluralize(fieldName);
+  }
+  const entityName = matches[matches.length - 1];
+  return pluralize(entityName);
+}
+function isRelationField(fieldName, zodType) {
+  return isSingleRelationField(fieldName, zodType) || isMultipleRelationField(fieldName, zodType);
+}
+function getMaxSelect(fieldName, zodType) {
+  if (isSingleRelationField(fieldName, zodType)) {
+    return 1;
+  }
+  if (isMultipleRelationField(fieldName, zodType)) {
+    let unwrappedType = zodType;
+    if (zodType instanceof z.ZodOptional) {
+      unwrappedType = zodType._def.innerType;
+    }
+    if (unwrappedType instanceof z.ZodNullable) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof z.ZodDefault) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof z.ZodArray) {
+      const arrayDef = unwrappedType._def;
+      if (arrayDef.maxLength) {
+        return arrayDef.maxLength.value;
+      }
+      return 999;
+    }
+  }
+  return 1;
+}
+function getMinSelect(fieldName, zodType) {
+  if (!isMultipleRelationField(fieldName, zodType)) {
+    return void 0;
+  }
+  let unwrappedType = zodType;
+  if (zodType instanceof z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodArray) {
+    const arrayDef = unwrappedType._def;
+    if (arrayDef.minLength) {
+      return arrayDef.minLength.value;
+    }
+  }
+  return void 0;
+}
+function mapZodStringType(zodType) {
+  const checks = zodType._def.checks || [];
+  const hasEmail = checks.some((check) => check.kind === "email");
+  if (hasEmail) {
+    return "email";
+  }
+  const hasUrl = checks.some((check) => check.kind === "url");
+  if (hasUrl) {
+    return "url";
+  }
+  const hasDatetime = checks.some((check) => check.kind === "datetime");
+  if (hasDatetime) {
+    return "date";
+  }
+  return "text";
+}
+function mapZodNumberType(_zodType) {
+  return "number";
+}
+function mapZodBooleanType(_zodType) {
+  return "bool";
+}
+function mapZodEnumType(_zodType) {
+  return "select";
+}
+function mapZodArrayType(zodType, _fieldName) {
+  const elementType = zodType._def.type;
+  if (elementType instanceof z.ZodType) {
+    const typeName = elementType._def.typeName;
+    if (typeName === "ZodType" && elementType._def?.innerType?.name === "File") {
+      return "file";
+    }
+  }
+  if (elementType._def?.typeName === "ZodType") {
+    const checks = elementType._def?.checks || [];
+    const isFileInstance = checks.some(
+      (check) => check.kind === "instanceof" || elementType._def?.innerType?.name === "File"
+    );
+    if (isFileInstance) {
+      return "file";
+    }
+  }
+  if (elementType instanceof z.ZodString) {
+    return "relation";
+  }
+  return "json";
+}
+function mapZodDateType(_zodType) {
+  return "date";
+}
+function mapZodRecordType(_zodType) {
+  return "json";
+}
+function mapZodTypeToPocketBase(zodType, fieldName) {
+  let unwrappedType = zodType;
+  if (zodType instanceof z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType._def?.typeName === "ZodEffects") {
+    const effect = unwrappedType._def?.effect;
+    if (effect?.type === "refinement") {
+      const fileFieldNames = ["avatar", "image", "file", "attachment", "photo", "picture", "document", "upload"];
+      if (fileFieldNames.some((name) => fieldName.toLowerCase().includes(name))) {
+        return "file";
+      }
+    }
+  }
+  if (unwrappedType._def?.typeName === "ZodType") {
+    const checks = unwrappedType._def?.checks || [];
+    const innerType = unwrappedType._def?.innerType;
+    if (innerType?.name === "File" || checks.some((check) => check.kind === "instanceof")) {
+      return "file";
+    }
+  }
+  if (unwrappedType instanceof z.ZodString) {
+    return mapZodStringType(unwrappedType);
+  }
+  if (unwrappedType instanceof z.ZodNumber) {
+    return mapZodNumberType();
+  }
+  if (unwrappedType instanceof z.ZodBoolean) {
+    return mapZodBooleanType();
+  }
+  if (unwrappedType instanceof z.ZodEnum) {
+    return mapZodEnumType();
+  }
+  if (unwrappedType instanceof z.ZodArray) {
+    return mapZodArrayType(unwrappedType);
+  }
+  if (unwrappedType instanceof z.ZodDate) {
+    return mapZodDateType();
+  }
+  if (unwrappedType instanceof z.ZodRecord || unwrappedType instanceof z.ZodObject) {
+    return mapZodRecordType();
+  }
+  return "text";
+}
+function extractFieldOptions(zodType) {
+  const options = {};
+  let unwrappedType = zodType;
+  if (zodType instanceof z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  const checks = unwrappedType._def?.checks || [];
+  if (unwrappedType instanceof z.ZodString) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+      if (check.kind === "regex") {
+        options.pattern = check.regex.source;
+      }
+    }
+  }
+  if (unwrappedType instanceof z.ZodNumber) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+    }
+  }
+  if (unwrappedType instanceof z.ZodEnum) {
+    options.values = unwrappedType._def.values;
+  }
+  if (unwrappedType instanceof z.ZodArray) {
+    const arrayChecks = unwrappedType._def?.checks || [];
+    for (const check of arrayChecks) {
+      if (check.kind === "min") {
+        options.minSelect = check.value;
+      }
+      if (check.kind === "max") {
+        options.maxSelect = check.value;
+      }
+    }
+  }
+  return options;
+}
+function isFieldRequired(zodType) {
+  if (zodType instanceof z.ZodOptional) {
+    return false;
+  }
+  if (zodType instanceof z.ZodDefault) {
+    return false;
+  }
+  if (zodType instanceof z.ZodNullable) {
+    return false;
+  }
+  return true;
+}
+
+// src/migration/analyzer.ts
+var DEFAULT_CONFIG = {
+  workspaceRoot: process.cwd(),
+  excludePatterns: [
+    "base.ts",
+    "index.ts",
+    "permissions.ts",
+    "permission-templates.ts",
+    "base.js",
+    "index.js",
+    "permissions.js",
+    "permission-templates.js"
+  ],
+  includeExtensions: [".ts", ".js"],
+  schemaPatterns: ["Schema", "InputSchema"],
+  useCompiledFiles: true
+};
+function mergeConfig(config) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    excludePatterns: config.excludePatterns || DEFAULT_CONFIG.excludePatterns,
+    includeExtensions: config.includeExtensions || DEFAULT_CONFIG.includeExtensions,
+    schemaPatterns: config.schemaPatterns || DEFAULT_CONFIG.schemaPatterns
+  };
+}
+function resolveSchemaDir(config) {
+  const workspaceRoot = config.workspaceRoot || process.cwd();
+  if (path4.isAbsolute(config.schemaDir)) {
+    return config.schemaDir;
+  }
+  return path4.join(workspaceRoot, config.schemaDir);
+}
+function discoverSchemaFiles(config) {
+  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
+  const mergedConfig = mergeConfig(normalizedConfig);
+  const schemaDir = resolveSchemaDir(normalizedConfig);
+  try {
+    if (!fs4.existsSync(schemaDir)) {
+      throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
+    }
+    const files = fs4.readdirSync(schemaDir);
+    const schemaFiles = files.filter((file) => {
+      const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
+      if (!hasValidExtension) return false;
+      const isExcluded = mergedConfig.excludePatterns.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+          return regex.test(file);
+        }
+        return file === pattern;
+      });
+      if (isExcluded) return false;
+      return true;
+    });
+    return schemaFiles.map((file) => {
+      const ext = mergedConfig.includeExtensions.find((ext2) => file.endsWith(ext2)) || ".ts";
+      return path4.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
+    });
+  } catch (error) {
+    if (error instanceof FileSystemError) {
+      throw error;
+    }
+    const fsError = error;
+    if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied reading schema directory: ${schemaDir}`,
+        schemaDir,
+        "read",
+        fsError.code,
+        error
+      );
+    }
+    throw new FileSystemError(
+      `Failed to read schema directory: ${schemaDir}`,
+      schemaDir,
+      "read",
+      fsError.code,
+      error
+    );
+  }
+}
+async function importSchemaModule(filePath, config) {
+  try {
+    let importPath = filePath;
+    if (config?.pathTransformer) {
+      importPath = config.pathTransformer(filePath);
+    }
+    if (!importPath.endsWith(".js")) {
+      importPath = `${importPath}.js`;
+    }
+    const fileUrl = new URL(`file://${path4.resolve(importPath)}`);
+    const module = await import(fileUrl.href);
+    return module;
+  } catch (error) {
+    throw new SchemaParsingError(
+      `Failed to import schema module. Make sure the schema files are compiled to JavaScript.`,
+      filePath,
+      error
+    );
+  }
+}
+function getCollectionNameFromFile(filePath) {
+  const filename = path4.basename(filePath).replace(/\.(ts|js)$/, "");
+  return toCollectionName(filename);
+}
+function extractSchemaDefinitions(module, patterns = ["Schema", "InputSchema"]) {
+  const result = {};
+  for (const [key, value] of Object.entries(module)) {
+    if (value instanceof z.ZodObject) {
+      if (patterns.includes("InputSchema") && key.endsWith("InputSchema")) {
+        result.inputSchema = value;
+      } else if (patterns.includes("Schema") && key.endsWith("Schema") && !key.endsWith("InputSchema")) {
+        result.schema = value;
+      }
+    }
+  }
+  return result;
+}
+function selectSchemaForCollection(schemas) {
+  if (schemas.schema) {
+    return schemas.schema;
+  }
+  if (schemas.inputSchema) {
+    return schemas.inputSchema;
+  }
+  return null;
+}
+function extractFieldDefinitions(zodSchema, excludeFields) {
+  const shape = zodSchema.shape;
+  const fields = [];
+  const baseFields = ["id", "collectionId", "collectionName", "created", "updated", "expand"];
+  const defaultExcludeFields = ["thumbnailURL", "imageFiles"];
+  const allExclusions = /* @__PURE__ */ new Set([...baseFields, ...defaultExcludeFields, ...[]]);
+  for (const [fieldName, zodType] of Object.entries(shape)) {
+    if (!allExclusions.has(fieldName)) {
+      fields.push({ name: fieldName, zodType });
+    }
+  }
+  return fields;
+}
+function isAuthCollection(fields) {
+  const fieldNames = fields.map((f) => f.name.toLowerCase());
+  const hasEmail = fieldNames.includes("email");
+  const hasPassword = fieldNames.includes("password");
+  return hasEmail && hasPassword;
+}
+function buildFieldDefinition(fieldName, zodType) {
+  const fieldType = mapZodTypeToPocketBase(zodType, fieldName);
+  const required = isFieldRequired(zodType);
+  const options = extractFieldOptions(zodType);
+  const fieldDef = {
+    name: fieldName,
+    type: fieldType,
+    required,
+    options
+  };
+  if (isRelationField(fieldName, zodType)) {
+    fieldDef.type = "relation";
+    const targetCollection = resolveTargetCollection(fieldName);
+    const maxSelect = getMaxSelect(fieldName, zodType);
+    const minSelect = getMinSelect(fieldName, zodType);
+    fieldDef.relation = {
+      collection: targetCollection,
+      maxSelect,
+      minSelect,
+      cascadeDelete: false
+      // Default to false, can be configured later
+    };
+  }
+  return fieldDef;
+}
+function extractIndexes(schema) {
+  const schemaDescription = schema.description;
+  if (!schemaDescription) {
+    return void 0;
+  }
+  try {
+    const metadata = JSON.parse(schemaDescription);
+    if (metadata.indexes && Array.isArray(metadata.indexes)) {
+      return metadata.indexes;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function convertZodSchemaToCollectionSchema(collectionName, zodSchema) {
+  const rawFields = extractFieldDefinitions(zodSchema);
+  const collectionType = isAuthCollection(rawFields) ? "auth" : "base";
+  const fields = rawFields.map(({ name, zodType }) => buildFieldDefinition(name, zodType));
+  const indexes = extractIndexes(zodSchema) || [];
+  const permissionAnalyzer = new PermissionAnalyzer();
+  let permissions = void 0;
+  const schemaDescription = zodSchema.description;
+  const extractedPermissions = permissionAnalyzer.extractPermissions(schemaDescription);
+  if (extractedPermissions) {
+    const resolvedPermissions = permissionAnalyzer.resolvePermissions(extractedPermissions);
+    const validationResults = permissionAnalyzer.validatePermissions(
+      collectionName,
+      resolvedPermissions,
+      fields,
+      collectionType === "auth"
+    );
+    for (const [ruleType, result] of validationResults) {
+      if (!result.valid) {
+        console.error(`[${collectionName}] Permission validation failed for ${ruleType}:`);
+        result.errors.forEach((error) => console.error(`  - ${error}`));
+      }
+      if (result.warnings.length > 0) {
+        console.warn(`[${collectionName}] Permission warnings for ${ruleType}:`);
+        result.warnings.forEach((warning) => console.warn(`  - ${warning}`));
+      }
+    }
+    permissions = permissionAnalyzer.mergeWithDefaults(resolvedPermissions);
+  }
+  const collectionSchema = {
+    name: collectionName,
+    type: collectionType,
+    fields,
+    indexes,
+    rules: {
+      listRule: null,
+      viewRule: null,
+      createRule: null,
+      updateRule: null,
+      deleteRule: null
+    },
+    permissions
+  };
+  return collectionSchema;
+}
+async function buildSchemaDefinition(config) {
+  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
+  const mergedConfig = mergeConfig(normalizedConfig);
+  const collections = /* @__PURE__ */ new Map();
+  const schemaFiles = discoverSchemaFiles(normalizedConfig);
+  if (schemaFiles.length === 0) {
+    const schemaDir = resolveSchemaDir(normalizedConfig);
+    throw new SchemaParsingError(
+      `No schema files found in ${schemaDir}. Make sure you have schema files in the directory.`,
+      schemaDir
+    );
+  }
+  for (const filePath of schemaFiles) {
+    try {
+      let importPath = filePath;
+      if (normalizedConfig.pathTransformer) {
+        importPath = normalizedConfig.pathTransformer(filePath);
+      } else if (mergedConfig.useCompiledFiles) {
+        importPath = filePath.replace(/\/src\//, "/dist/");
+      }
+      const module = await importSchemaModule(importPath, normalizedConfig);
+      const schemas = extractSchemaDefinitions(module, mergedConfig.schemaPatterns);
+      const zodSchema = selectSchemaForCollection(schemas);
+      if (!zodSchema) {
+        console.warn(`No valid schema found in ${filePath}, skipping...`);
+        continue;
+      }
+      const collectionName = getCollectionNameFromFile(filePath);
+      const collectionSchema = convertZodSchemaToCollectionSchema(collectionName, zodSchema);
+      collections.set(collectionName, collectionSchema);
+    } catch (error) {
+      if (error instanceof SchemaParsingError) {
+        throw error;
+      }
+      throw new SchemaParsingError(
+        `Error processing schema file: ${error instanceof Error ? error.message : String(error)}`,
+        filePath,
+        error
+      );
+    }
+  }
+  return { collections };
+}
+async function parseSchemaFiles(config) {
+  return buildSchemaDefinition(config);
+}
+
+// src/migration/diff.ts
+var DEFAULT_CONFIG2 = {
+  warnOnDelete: true,
+  requireForceForDestructive: true,
+  severityThreshold: "high",
+  systemCollections: ["_mfas", "_otps", "_externalAuths", "_authOrigins", "_superusers"],
+  usersSystemFields: ["id", "password", "tokenKey", "email", "emailVisibility", "verified", "created", "updated"]
+};
+function mergeConfig2(config) {
+  return {
+    ...DEFAULT_CONFIG2,
+    ...config
+  };
+}
+function isSystemCollection(collectionName, config) {
+  const mergedConfig = mergeConfig2(config);
+  return mergedConfig.systemCollections.includes(collectionName);
+}
+function getUsersSystemFields(config) {
+  const mergedConfig = mergeConfig2(config);
+  return new Set(mergedConfig.usersSystemFields);
+}
+function findNewCollections(currentSchema, previousSnapshot) {
+  const newCollections = [];
+  if (!previousSnapshot) {
+    return Array.from(currentSchema.collections.values());
+  }
+  for (const [collectionName, collectionSchema] of currentSchema.collections) {
+    if (!previousSnapshot.collections.has(collectionName)) {
+      newCollections.push(collectionSchema);
+    }
+  }
+  return newCollections;
+}
+function findRemovedCollections(currentSchema, previousSnapshot) {
+  const removedCollections = [];
+  if (!previousSnapshot) {
+    return removedCollections;
+  }
+  for (const [collectionName, collectionSchema] of previousSnapshot.collections) {
+    if (!currentSchema.collections.has(collectionName)) {
+      removedCollections.push(collectionSchema);
+    }
+  }
+  return removedCollections;
+}
+function matchCollectionsByName(currentSchema, previousSnapshot) {
+  const matches = [];
+  if (!previousSnapshot) {
+    return matches;
+  }
+  for (const [collectionName, currentCollection] of currentSchema.collections) {
+    const previousCollection = previousSnapshot.collections.get(collectionName);
+    if (previousCollection) {
+      matches.push([currentCollection, previousCollection]);
+    }
+  }
+  return matches;
+}
+function findNewFields(currentFields, previousFields) {
+  const newFields = [];
+  const previousFieldNames = new Set(previousFields.map((f) => f.name));
+  for (const currentField of currentFields) {
+    if (!previousFieldNames.has(currentField.name)) {
+      newFields.push(currentField);
+    }
+  }
+  return newFields;
+}
+function findRemovedFields(currentFields, previousFields) {
+  const removedFields = [];
+  const currentFieldNames = new Set(currentFields.map((f) => f.name));
+  for (const previousField of previousFields) {
+    if (!currentFieldNames.has(previousField.name)) {
+      removedFields.push(previousField);
+    }
+  }
+  return removedFields;
+}
+function matchFieldsByName(currentFields, previousFields) {
+  const matches = [];
+  const previousFieldMap = /* @__PURE__ */ new Map();
+  for (const previousField of previousFields) {
+    previousFieldMap.set(previousField.name, previousField);
+  }
+  for (const currentField of currentFields) {
+    const previousField = previousFieldMap.get(currentField.name);
+    if (previousField) {
+      matches.push([currentField, previousField]);
+    }
+  }
+  return matches;
+}
+function areValuesEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, idx) => areValuesEqual(val, b[idx]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => areValuesEqual(a[key], b[key]));
+  }
+  return a === b;
+}
+function compareFieldTypes(currentField, previousField) {
+  if (currentField.type !== previousField.type) {
+    return {
+      property: "type",
+      oldValue: previousField.type,
+      newValue: currentField.type
+    };
+  }
+  return null;
+}
+function compareFieldConstraints(currentField, previousField) {
+  const changes = [];
+  if (currentField.required !== previousField.required) {
+    changes.push({
+      property: "required",
+      oldValue: previousField.required,
+      newValue: currentField.required
+    });
+  }
+  if (currentField.unique !== previousField.unique) {
+    changes.push({
+      property: "unique",
+      oldValue: previousField.unique,
+      newValue: currentField.unique
+    });
+  }
+  return changes;
+}
+function compareFieldOptions(currentField, previousField) {
+  const changes = [];
+  const currentOptions = currentField.options || {};
+  const previousOptions = previousField.options || {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(currentOptions), ...Object.keys(previousOptions)]);
+  for (const key of allKeys) {
+    const currentValue = currentOptions[key];
+    const previousValue = previousOptions[key];
+    if (!areValuesEqual(currentValue, previousValue)) {
+      changes.push({
+        property: `options.${key}`,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return changes;
+}
+function compareRelationConfigurations(currentField, previousField) {
+  const changes = [];
+  const currentRelation = currentField.relation;
+  const previousRelation = previousField.relation;
+  if (!currentRelation && !previousRelation) {
+    return changes;
+  }
+  if (!currentRelation || !previousRelation) {
+    return changes;
+  }
+  if (currentRelation.collection !== previousRelation.collection) {
+    changes.push({
+      property: "relation.collection",
+      oldValue: previousRelation.collection,
+      newValue: currentRelation.collection
+    });
+  }
+  if (currentRelation.cascadeDelete !== previousRelation.cascadeDelete) {
+    changes.push({
+      property: "relation.cascadeDelete",
+      oldValue: previousRelation.cascadeDelete,
+      newValue: currentRelation.cascadeDelete
+    });
+  }
+  if (currentRelation.maxSelect !== previousRelation.maxSelect) {
+    changes.push({
+      property: "relation.maxSelect",
+      oldValue: previousRelation.maxSelect,
+      newValue: currentRelation.maxSelect
+    });
+  }
+  if (currentRelation.minSelect !== previousRelation.minSelect) {
+    changes.push({
+      property: "relation.minSelect",
+      oldValue: previousRelation.minSelect,
+      newValue: currentRelation.minSelect
+    });
+  }
+  return changes;
+}
+function detectFieldChanges(currentField, previousField) {
+  const changes = [];
+  const typeChange = compareFieldTypes(currentField, previousField);
+  if (typeChange) {
+    changes.push(typeChange);
+  }
+  changes.push(...compareFieldConstraints(currentField, previousField));
+  changes.push(...compareFieldOptions(currentField, previousField));
+  if (currentField.type === "relation" && previousField.type === "relation") {
+    changes.push(...compareRelationConfigurations(currentField, previousField));
+  }
+  return changes;
+}
+function compareIndexes(currentIndexes = [], previousIndexes = []) {
+  const currentSet = new Set(currentIndexes);
+  const previousSet = new Set(previousIndexes);
+  const indexesToAdd = currentIndexes.filter((idx) => !previousSet.has(idx));
+  const indexesToRemove = previousIndexes.filter((idx) => !currentSet.has(idx));
+  return { indexesToAdd, indexesToRemove };
+}
+function compareRules(currentRules, previousRules) {
+  const updates = [];
+  const ruleTypes = [
+    "listRule",
+    "viewRule",
+    "createRule",
+    "updateRule",
+    "deleteRule",
+    "manageRule"
+  ];
+  for (const ruleType of ruleTypes) {
+    const currentValue = currentRules?.[ruleType] ?? null;
+    const previousValue = previousRules?.[ruleType] ?? null;
+    if (currentValue !== previousValue) {
+      updates.push({
+        ruleType,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return updates;
+}
+function comparePermissions(currentPermissions, previousPermissions) {
+  const changes = [];
+  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule", "manageRule"];
+  for (const ruleType of ruleTypes) {
+    const currentValue = currentPermissions?.[ruleType] ?? null;
+    const previousValue = previousPermissions?.[ruleType] ?? null;
+    if (currentValue !== previousValue) {
+      changes.push({
+        ruleType,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return changes;
+}
+function compareCollectionFields(currentCollection, previousCollection, config) {
+  let fieldsToAdd = findNewFields(currentCollection.fields, previousCollection.fields);
+  const fieldsToRemove = findRemovedFields(currentCollection.fields, previousCollection.fields);
+  const fieldsToModify = [];
+  if (currentCollection.name === "users") {
+    const systemFields = getUsersSystemFields(config);
+    fieldsToAdd = fieldsToAdd.filter((field) => !systemFields.has(field.name));
+  }
+  const matchedFields = matchFieldsByName(currentCollection.fields, previousCollection.fields);
+  for (const [currentField, previousField] of matchedFields) {
+    const changes = detectFieldChanges(currentField, previousField);
+    if (changes.length > 0) {
+      fieldsToModify.push({
+        fieldName: currentField.name,
+        currentDefinition: previousField,
+        newDefinition: currentField,
+        changes
+      });
+    }
+  }
+  return { fieldsToAdd, fieldsToRemove, fieldsToModify };
+}
+function buildCollectionModification(currentCollection, previousCollection, config) {
+  const { fieldsToAdd, fieldsToRemove, fieldsToModify } = compareCollectionFields(
+    currentCollection,
+    previousCollection,
+    config
+  );
+  const { indexesToAdd, indexesToRemove } = compareIndexes(currentCollection.indexes, previousCollection.indexes);
+  const rulesToUpdate = compareRules(currentCollection.rules, previousCollection.rules);
+  const permissionsToUpdate = comparePermissions(currentCollection.permissions, previousCollection.permissions);
+  return {
+    collection: currentCollection.name,
+    fieldsToAdd,
+    fieldsToRemove,
+    fieldsToModify,
+    indexesToAdd,
+    indexesToRemove,
+    rulesToUpdate,
+    permissionsToUpdate
+  };
+}
+function hasChanges(modification) {
+  return modification.fieldsToAdd.length > 0 || modification.fieldsToRemove.length > 0 || modification.fieldsToModify.length > 0 || modification.indexesToAdd.length > 0 || modification.indexesToRemove.length > 0 || modification.rulesToUpdate.length > 0 || modification.permissionsToUpdate.length > 0;
+}
+function aggregateChanges(currentSchema, previousSnapshot, config) {
+  const collectionsToCreate = findNewCollections(currentSchema, previousSnapshot);
+  const collectionsToDelete = findRemovedCollections(currentSchema, previousSnapshot);
+  const filteredCollectionsToCreate = collectionsToCreate.filter(
+    (collection) => !isSystemCollection(collection.name, config)
+  );
+  const filteredCollectionsToDelete = collectionsToDelete.filter(
+    (collection) => !isSystemCollection(collection.name, config)
+  );
+  const collectionsToModify = [];
+  const matchedCollections = matchCollectionsByName(currentSchema, previousSnapshot);
+  for (const [currentCollection, previousCollection] of matchedCollections) {
+    const modification = buildCollectionModification(currentCollection, previousCollection, config);
+    if (hasChanges(modification)) {
+      collectionsToModify.push(modification);
+    }
+  }
+  return {
+    collectionsToCreate: filteredCollectionsToCreate,
+    collectionsToDelete: filteredCollectionsToDelete,
+    collectionsToModify
+  };
+}
+function categorizeChangesBySeverity(diff, _config) {
+  const destructive = [];
+  const nonDestructive = [];
+  for (const collection of diff.collectionsToDelete) {
+    destructive.push(`Delete collection: ${collection.name}`);
+  }
+  for (const collection of diff.collectionsToCreate) {
+    nonDestructive.push(`Create collection: ${collection.name}`);
+  }
+  for (const modification of diff.collectionsToModify) {
+    const collectionName = modification.collection;
+    for (const field of modification.fieldsToRemove) {
+      destructive.push(`Delete field: ${collectionName}.${field.name}`);
+    }
+    for (const field of modification.fieldsToAdd) {
+      nonDestructive.push(`Add field: ${collectionName}.${field.name}`);
+    }
+    for (const fieldMod of modification.fieldsToModify) {
+      const hasTypeChange = fieldMod.changes.some((c) => c.property === "type");
+      const hasRequiredChange = fieldMod.changes.some((c) => c.property === "required" && c.newValue === true);
+      if (hasTypeChange) {
+        destructive.push(
+          `Change field type: ${collectionName}.${fieldMod.fieldName} (${fieldMod.changes.find((c) => c.property === "type")?.oldValue} \u2192 ${fieldMod.changes.find((c) => c.property === "type")?.newValue})`
+        );
+      } else if (hasRequiredChange) {
+        destructive.push(`Make field required: ${collectionName}.${fieldMod.fieldName}`);
+      } else {
+        nonDestructive.push(`Modify field: ${collectionName}.${fieldMod.fieldName}`);
+      }
+    }
+    for (const _index of modification.indexesToAdd) {
+      nonDestructive.push(`Add index: ${collectionName}`);
+    }
+    for (const _index of modification.indexesToRemove) {
+      nonDestructive.push(`Remove index: ${collectionName}`);
+    }
+    for (const rule of modification.rulesToUpdate) {
+      nonDestructive.push(`Update rule: ${collectionName}.${rule.ruleType}`);
+    }
+  }
+  return { destructive, nonDestructive };
+}
+function compare(currentSchema, previousSnapshot, config) {
+  return aggregateChanges(currentSchema, previousSnapshot, config);
+}
+var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
+migrate((app) => {
+{{UP_CODE}}
+  return true;
+}, (app) => {
+{{DOWN_CODE}}
+  return true;
+});
+`;
+var DEFAULT_CONFIG3 = {
+  workspaceRoot: process.cwd(),
+  timestampGenerator: () => Math.floor(Date.now() / 1e3).toString(),
+  template: DEFAULT_TEMPLATE,
+  includeTypeReference: true,
+  typesPath: "../pb_data/types.d.ts"
+};
+function mergeConfig3(config) {
+  return {
+    ...DEFAULT_CONFIG3,
+    ...config
+  };
+}
+function resolveMigrationDir(config) {
+  const workspaceRoot = config.workspaceRoot || process.cwd();
+  if (path4.isAbsolute(config.migrationDir)) {
+    return config.migrationDir;
+  }
+  return path4.join(workspaceRoot, config.migrationDir);
+}
+function generateTimestamp(config) {
+  if (config?.timestampGenerator) {
+    return config.timestampGenerator();
+  }
+  return Math.floor(Date.now() / 1e3).toString();
+}
+function generateMigrationDescription(diff) {
+  const parts = [];
+  if (diff.collectionsToCreate.length > 0) {
+    if (diff.collectionsToCreate.length === 1) {
+      parts.push(`created_${diff.collectionsToCreate[0].name}`);
+    } else {
+      parts.push(`created_${diff.collectionsToCreate.length}_collections`);
+    }
+  }
+  if (diff.collectionsToDelete.length > 0) {
+    if (diff.collectionsToDelete.length === 1) {
+      parts.push(`deleted_${diff.collectionsToDelete[0].name}`);
+    } else {
+      parts.push(`deleted_${diff.collectionsToDelete.length}_collections`);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    if (diff.collectionsToModify.length === 1) {
+      parts.push(`updated_${diff.collectionsToModify[0].collection}`);
+    } else {
+      parts.push(`updated_${diff.collectionsToModify.length}_collections`);
+    }
+  }
+  if (parts.length === 0) {
+    return "no_changes";
+  }
+  let description = parts.join("_");
+  if (description.length > 80) {
+    description = description.substring(0, 77) + "...";
+  }
+  return description;
+}
+function generateMigrationFilename(diff, config) {
+  const timestamp = generateTimestamp(config);
+  const description = generateMigrationDescription(diff);
+  return `${timestamp}_${description}.js`;
+}
+function createMigrationFileStructure(upCode, downCode, config) {
+  const mergedConfig = config ? mergeConfig3(config) : DEFAULT_CONFIG3;
+  let template = mergedConfig.template;
+  template = template.replace("{{TYPES_PATH}}", mergedConfig.typesPath);
+  template = template.replace("{{UP_CODE}}", upCode);
+  template = template.replace("{{DOWN_CODE}}", downCode);
+  if (!mergedConfig.includeTypeReference) {
+    template = template.replace(/\/\/\/ <reference path="[^"]*" \/>\n?/, "");
+  }
+  return template;
+}
+function writeMigrationFile(migrationDir, filename, content) {
+  try {
+    if (!fs4.existsSync(migrationDir)) {
+      try {
+        fs4.mkdirSync(migrationDir, { recursive: true });
+      } catch (error) {
+        const fsError = error;
+        if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+          throw new FileSystemError(
+            `Permission denied creating migration directory. Check directory permissions.`,
+            migrationDir,
+            "create",
+            fsError.code,
+            error
+          );
+        }
+        throw new FileSystemError(
+          `Failed to create migration directory: ${fsError.message}`,
+          migrationDir,
+          "create",
+          fsError.code,
+          error
+        );
+      }
+    }
+    const filePath = path4.join(migrationDir, filename);
+    fs4.writeFileSync(filePath, content, "utf-8");
+    return filePath;
+  } catch (error) {
+    if (error instanceof FileSystemError) {
+      throw error;
+    }
+    const fsError = error;
+    const filePath = path4.join(migrationDir, filename);
+    if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied writing migration file. Check file and directory permissions.`,
+        filePath,
+        "write",
+        fsError.code,
+        error
+      );
+    } else if (fsError.code === "ENOSPC") {
+      throw new FileSystemError(
+        `No space left on device when writing migration file.`,
+        filePath,
+        "write",
+        fsError.code,
+        error
+      );
+    }
+    throw new MigrationGenerationError(`Failed to write migration file: ${fsError.message}`, filePath, error);
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => formatValue(v)).join(", ");
+    return `[${items}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ");
+    return `{ ${entries} }`;
+  }
+  return String(value);
+}
+function generateFieldDefinitionObject(field) {
+  const parts = [];
+  parts.push(`      name: "${field.name}"`);
+  parts.push(`      type: "${field.type}"`);
+  parts.push(`      required: ${field.required}`);
+  if (field.unique !== void 0) {
+    parts.push(`      unique: ${field.unique}`);
+  }
+  if (field.options && Object.keys(field.options).length > 0) {
+    for (const [key, value] of Object.entries(field.options)) {
+      parts.push(`      ${key}: ${formatValue(value)}`);
+    }
+  }
+  if (field.relation) {
+    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    parts.push(`      collectionId: ${collectionIdPlaceholder}`);
+    if (field.relation.maxSelect !== void 0) {
+      parts.push(`      maxSelect: ${field.relation.maxSelect}`);
+    }
+    if (field.relation.minSelect !== void 0) {
+      parts.push(`      minSelect: ${field.relation.minSelect}`);
+    }
+    if (field.relation.cascadeDelete !== void 0) {
+      parts.push(`      cascadeDelete: ${field.relation.cascadeDelete}`);
+    }
+  }
+  return `    {
+${parts.join(",\n")},
+    }`;
+}
+function generateFieldsArray(fields) {
+  if (fields.length === 0) {
+    return "[]";
+  }
+  const fieldObjects = fields.map((field) => generateFieldDefinitionObject(field));
+  return `[
+${fieldObjects.join(",\n")},
+  ]`;
+}
+function generateCollectionRules(rules) {
+  if (!rules) {
+    return "";
+  }
+  const parts = [];
+  if (rules.listRule !== void 0) {
+    parts.push(`listRule: ${formatValue(rules.listRule)}`);
+  }
+  if (rules.viewRule !== void 0) {
+    parts.push(`viewRule: ${formatValue(rules.viewRule)}`);
+  }
+  if (rules.createRule !== void 0) {
+    parts.push(`createRule: ${formatValue(rules.createRule)}`);
+  }
+  if (rules.updateRule !== void 0) {
+    parts.push(`updateRule: ${formatValue(rules.updateRule)}`);
+  }
+  if (rules.deleteRule !== void 0) {
+    parts.push(`deleteRule: ${formatValue(rules.deleteRule)}`);
+  }
+  if (rules.manageRule !== void 0) {
+    parts.push(`manageRule: ${formatValue(rules.manageRule)}`);
+  }
+  return parts.join(",\n    ");
+}
+function generateCollectionPermissions(permissions) {
+  if (!permissions) {
+    return "";
+  }
+  const parts = [];
+  if (permissions.listRule !== void 0) {
+    parts.push(`listRule: ${formatValue(permissions.listRule)}`);
+  }
+  if (permissions.viewRule !== void 0) {
+    parts.push(`viewRule: ${formatValue(permissions.viewRule)}`);
+  }
+  if (permissions.createRule !== void 0) {
+    parts.push(`createRule: ${formatValue(permissions.createRule)}`);
+  }
+  if (permissions.updateRule !== void 0) {
+    parts.push(`updateRule: ${formatValue(permissions.updateRule)}`);
+  }
+  if (permissions.deleteRule !== void 0) {
+    parts.push(`deleteRule: ${formatValue(permissions.deleteRule)}`);
+  }
+  if (permissions.manageRule !== void 0) {
+    parts.push(`manageRule: ${formatValue(permissions.manageRule)}`);
+  }
+  return parts.join(",\n    ");
+}
+function generateIndexesArray(indexes) {
+  if (!indexes || indexes.length === 0) {
+    return "[]";
+  }
+  const indexStrings = indexes.map((idx) => `"${idx}"`);
+  return `[
+    ${indexStrings.join(",\n    ")},
+  ]`;
+}
+function generateCollectionCreation(collection, varName = "collection") {
+  const lines = [];
+  lines.push(`  const ${varName} = new Collection({`);
+  lines.push(`    name: "${collection.name}",`);
+  lines.push(`    type: "${collection.type}",`);
+  const permissionsCode = generateCollectionPermissions(collection.permissions);
+  const rulesCode = generateCollectionRules(collection.rules);
+  if (permissionsCode) {
+    lines.push(`    ${permissionsCode},`);
+  } else if (rulesCode) {
+    lines.push(`    ${rulesCode},`);
+  }
+  lines.push(`    fields: ${generateFieldsArray(collection.fields)},`);
+  lines.push(`    indexes: ${generateIndexesArray(collection.indexes)},`);
+  lines.push(`  });`);
+  lines.push(``);
+  lines.push(`  app.save(${varName});`);
+  return lines.join("\n");
+}
+function getFieldConstructorName(fieldType) {
+  const constructorMap = {
+    text: "TextField",
+    email: "EmailField",
+    url: "URLField",
+    number: "NumberField",
+    bool: "BoolField",
+    date: "DateField",
+    select: "SelectField",
+    relation: "RelationField",
+    file: "FileField",
+    json: "JSONField"
+  };
+  return constructorMap[fieldType] || "TextField";
+}
+function generateFieldConstructorOptions(field) {
+  const parts = [];
+  parts.push(`    name: "${field.name}"`);
+  parts.push(`    required: ${field.required}`);
+  if (field.unique !== void 0) {
+    parts.push(`    unique: ${field.unique}`);
+  }
+  if (field.options && Object.keys(field.options).length > 0) {
+    for (const [key, value] of Object.entries(field.options)) {
+      parts.push(`    ${key}: ${formatValue(value)}`);
+    }
+  }
+  if (field.relation && field.type === "relation") {
+    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    parts.push(`    collectionId: ${collectionIdPlaceholder}`);
+    if (field.relation.maxSelect !== void 0) {
+      parts.push(`    maxSelect: ${field.relation.maxSelect}`);
+    }
+    if (field.relation.minSelect !== void 0) {
+      parts.push(`    minSelect: ${field.relation.minSelect}`);
+    }
+    if (field.relation.cascadeDelete !== void 0) {
+      parts.push(`    cascadeDelete: ${field.relation.cascadeDelete}`);
+    }
+  }
+  return parts.join(",\n");
+}
+function generateFieldAddition(collectionName, field, varName) {
+  const lines = [];
+  const constructorName = getFieldConstructorName(field.type);
+  const collectionVar = varName || `collection_${collectionName}_${field.name}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(``);
+  lines.push(`  ${collectionVar}.fields.add(new ${constructorName}({`);
+  lines.push(generateFieldConstructorOptions(field));
+  lines.push(`  }));`);
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateFieldModification(collectionName, modification, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${modification.fieldName}`;
+  const fieldVar = `${collectionVar}_field`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${fieldVar} = ${collectionVar}.fields.getByName("${modification.fieldName}");`);
+  lines.push(``);
+  for (const change of modification.changes) {
+    if (change.property.startsWith("options.")) {
+      const optionKey = change.property.replace("options.", "");
+      lines.push(`  ${fieldVar}.${optionKey} = ${formatValue(change.newValue)};`);
+    } else if (change.property.startsWith("relation.")) {
+      const relationKey = change.property.replace("relation.", "");
+      if (relationKey === "collection") {
+        const collectionIdValue = change.newValue === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${change.newValue}").id`;
+        lines.push(`  ${fieldVar}.collectionId = ${collectionIdValue};`);
+      } else {
+        lines.push(`  ${fieldVar}.${relationKey} = ${formatValue(change.newValue)};`);
+      }
+    } else {
+      lines.push(`  ${fieldVar}.${change.property} = ${formatValue(change.newValue)};`);
+    }
+  }
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateFieldDeletion(collectionName, fieldName, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${fieldName}`;
+  const fieldVar = `${collectionVar}_field`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${fieldVar} = ${collectionVar}.fields.getByName("${fieldName}");`);
+  lines.push(``);
+  lines.push(`  ${collectionVar}.fields.remove(${fieldVar}.id);`);
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateIndexAddition(collectionName, index, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_idx`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.indexes.push("${index}");`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateIndexRemoval(collectionName, index, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_idx`;
+  const indexVar = `${collectionVar}_indexToRemove`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${indexVar} = ${collectionVar}.indexes.findIndex(idx => idx === "${index}");`);
+  lines.push(`  if (${indexVar} !== -1) {`);
+  lines.push(`    ${collectionVar}.indexes.splice(${indexVar}, 1);`);
+  lines.push(`  }`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateRuleUpdate(collectionName, ruleType, newValue, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${ruleType}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.${ruleType} = ${formatValue(newValue)};`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generatePermissionUpdate(collectionName, ruleType, newValue, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${ruleType}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.${ruleType} = ${formatValue(newValue)};`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateCollectionDeletion(collectionName, varName = "collection") {
+  const lines = [];
+  lines.push(`  const ${varName} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  app.delete(${varName});`);
+  return lines.join("\n");
+}
+function generateUpMigration(diff) {
+  const lines = [];
+  lines.push(`  // UP MIGRATION`);
+  lines.push(``);
+  if (diff.collectionsToCreate.length > 0) {
+    lines.push(`  // Create new collections`);
+    for (let i = 0; i < diff.collectionsToCreate.length; i++) {
+      const collection = diff.collectionsToCreate[i];
+      const varName = `collection_${collection.name}_create`;
+      lines.push(generateCollectionCreation(collection, varName));
+      lines.push(``);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    lines.push(`  // Modify existing collections`);
+    for (const modification of diff.collectionsToModify) {
+      const collectionName = modification.collection;
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(`  // Add fields to ${collectionName}`);
+        for (const field of modification.fieldsToAdd) {
+          const varName = `collection_${collectionName}_add_${field.name}`;
+          lines.push(generateFieldAddition(collectionName, field, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(`  // Modify fields in ${collectionName}`);
+        for (const fieldMod of modification.fieldsToModify) {
+          const varName = `collection_${collectionName}_modify_${fieldMod.fieldName}`;
+          lines.push(generateFieldModification(collectionName, fieldMod, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(`  // Remove fields from ${collectionName}`);
+        for (const field of modification.fieldsToRemove) {
+          const varName = `collection_${collectionName}_remove_${field.name}`;
+          lines.push(generateFieldDeletion(collectionName, field.name, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(`  // Add indexes to ${collectionName}`);
+        for (let i = 0; i < modification.indexesToAdd.length; i++) {
+          const index = modification.indexesToAdd[i];
+          const varName = `collection_${collectionName}_addidx_${i}`;
+          lines.push(generateIndexAddition(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(`  // Remove indexes from ${collectionName}`);
+        for (let i = 0; i < modification.indexesToRemove.length; i++) {
+          const index = modification.indexesToRemove[i];
+          const varName = `collection_${collectionName}_rmidx_${i}`;
+          lines.push(generateIndexRemoval(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.permissionsToUpdate && modification.permissionsToUpdate.length > 0) {
+        lines.push(`  // Update permissions for ${collectionName}`);
+        for (const permission of modification.permissionsToUpdate) {
+          const varName = `collection_${collectionName}_perm_${permission.ruleType}`;
+          lines.push(generatePermissionUpdate(collectionName, permission.ruleType, permission.newValue, varName));
+          lines.push(``);
+        }
+      } else if (modification.rulesToUpdate.length > 0) {
+        lines.push(`  // Update rules for ${collectionName}`);
+        for (const rule of modification.rulesToUpdate) {
+          const varName = `collection_${collectionName}_rule_${rule.ruleType}`;
+          lines.push(generateRuleUpdate(collectionName, rule.ruleType, rule.newValue, varName));
+          lines.push(``);
+        }
+      }
+    }
+  }
+  if (diff.collectionsToDelete.length > 0) {
+    lines.push(`  // Delete collections`);
+    for (let i = 0; i < diff.collectionsToDelete.length; i++) {
+      const collection = diff.collectionsToDelete[i];
+      const varName = `collection_${collection.name}_delete`;
+      lines.push(generateCollectionDeletion(collection.name, varName));
+      lines.push(``);
+    }
+  }
+  if (lines.length === 2) {
+    lines.push(`  // No changes detected`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function generateDownMigration(diff) {
+  const lines = [];
+  lines.push(`  // DOWN MIGRATION (ROLLBACK)`);
+  lines.push(``);
+  if (diff.collectionsToDelete.length > 0) {
+    lines.push(`  // Recreate deleted collections`);
+    for (let i = 0; i < diff.collectionsToDelete.length; i++) {
+      const collection = diff.collectionsToDelete[i];
+      const varName = `collection_${collection.name}_recreate`;
+      lines.push(generateCollectionCreation(collection, varName));
+      lines.push(``);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    lines.push(`  // Revert modifications`);
+    for (const modification of diff.collectionsToModify) {
+      const collectionName = modification.collection;
+      if (modification.permissionsToUpdate && modification.permissionsToUpdate.length > 0) {
+        lines.push(`  // Revert permissions for ${collectionName}`);
+        for (const permission of modification.permissionsToUpdate) {
+          const varName = `collection_${collectionName}_revert_perm_${permission.ruleType}`;
+          lines.push(generatePermissionUpdate(collectionName, permission.ruleType, permission.oldValue, varName));
+          lines.push(``);
+        }
+      } else if (modification.rulesToUpdate.length > 0) {
+        lines.push(`  // Revert rules for ${collectionName}`);
+        for (const rule of modification.rulesToUpdate) {
+          const varName = `collection_${collectionName}_revert_rule_${rule.ruleType}`;
+          lines.push(generateRuleUpdate(collectionName, rule.ruleType, rule.oldValue, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(`  // Restore indexes to ${collectionName}`);
+        for (let i = 0; i < modification.indexesToRemove.length; i++) {
+          const index = modification.indexesToRemove[i];
+          const varName = `collection_${collectionName}_restore_idx_${i}`;
+          lines.push(generateIndexAddition(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(`  // Remove indexes from ${collectionName}`);
+        for (let i = 0; i < modification.indexesToAdd.length; i++) {
+          const index = modification.indexesToAdd[i];
+          const varName = `collection_${collectionName}_revert_idx_${i}`;
+          lines.push(generateIndexRemoval(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(`  // Restore fields to ${collectionName}`);
+        for (const field of modification.fieldsToRemove) {
+          const varName = `collection_${collectionName}_restore_${field.name}`;
+          lines.push(generateFieldAddition(collectionName, field, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(`  // Revert field modifications in ${collectionName}`);
+        for (const fieldMod of modification.fieldsToModify) {
+          const reverseChanges = fieldMod.changes.map((change) => ({
+            property: change.property,
+            oldValue: change.newValue,
+            newValue: change.oldValue
+          }));
+          const reverseMod = {
+            fieldName: fieldMod.fieldName,
+            currentDefinition: fieldMod.newDefinition,
+            newDefinition: fieldMod.currentDefinition,
+            changes: reverseChanges
+          };
+          const varName = `collection_${collectionName}_revert_${fieldMod.fieldName}`;
+          lines.push(generateFieldModification(collectionName, reverseMod, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(`  // Remove added fields from ${collectionName}`);
+        for (const field of modification.fieldsToAdd) {
+          const varName = `collection_${collectionName}_revert_add_${field.name}`;
+          lines.push(generateFieldDeletion(collectionName, field.name, varName));
+          lines.push(``);
+        }
+      }
+    }
+  }
+  if (diff.collectionsToCreate.length > 0) {
+    lines.push(`  // Delete created collections`);
+    for (let i = 0; i < diff.collectionsToCreate.length; i++) {
+      const collection = diff.collectionsToCreate[i];
+      const varName = `collection_${collection.name}_rollback`;
+      lines.push(generateCollectionDeletion(collection.name, varName));
+      lines.push(``);
+    }
+  }
+  if (lines.length === 2) {
+    lines.push(`  // No changes to revert`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function generate(diff, config) {
+  const normalizedConfig = typeof config === "string" ? { migrationDir: config } : config;
+  try {
+    const migrationDir = resolveMigrationDir(normalizedConfig);
+    const upCode = generateUpMigration(diff);
+    const downCode = generateDownMigration(diff);
+    const content = createMigrationFileStructure(upCode, downCode, normalizedConfig);
+    const filename = generateMigrationFilename(diff, normalizedConfig);
+    const filePath = writeMigrationFile(migrationDir, filename, content);
+    return filePath;
+  } catch (error) {
+    if (error instanceof MigrationGenerationError || error instanceof FileSystemError) {
+      throw error;
+    }
+    throw new MigrationGenerationError(
+      `Failed to generate migration: ${error instanceof Error ? error.message : String(error)}`,
+      normalizedConfig.migrationDir,
+      error
+    );
+  }
+}
+var SNAPSHOT_VERSION = "1.0.0";
+({
+  workspaceRoot: process.cwd()});
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs4.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs4.readdirSync(migrationsPath);
+    const snapshotFiles = files.filter(
+      (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
+    );
+    if (snapshotFiles.length === 0) {
+      return null;
+    }
+    snapshotFiles.sort().reverse();
+    const latestSnapshot = snapshotFiles[0];
+    if (!latestSnapshot) {
+      return null;
+    }
+    return path4.join(migrationsPath, latestSnapshot);
+  } catch (error) {
+    console.warn(`Error finding latest snapshot: ${error}`);
+    return null;
+  }
+}
+function loadSnapshotIfExists(config = {}) {
+  const migrationsPath = config.migrationsPath;
+  if (!migrationsPath) {
+    return null;
+  }
+  if (fs4.existsSync(migrationsPath) && fs4.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs4.readFileSync(migrationsPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
+      return null;
+    }
+  }
+  const latestSnapshotPath = findLatestSnapshot(migrationsPath);
+  if (latestSnapshotPath) {
+    try {
+      const migrationContent = fs4.readFileSync(latestSnapshotPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
+      return null;
+    }
+  }
+  return null;
+}
+function convertPocketBaseCollection(pbCollection) {
+  const fields = [];
+  const systemFieldNames = ["id", "created", "updated", "collectionId", "collectionName", "expand"];
+  const authSystemFieldNames = ["email", "emailVisibility", "verified", "password", "tokenKey"];
+  if (pbCollection.fields && Array.isArray(pbCollection.fields)) {
+    for (const pbField of pbCollection.fields) {
+      if (pbField.system || systemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      if (pbCollection.type === "auth" && authSystemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      const field = {
+        name: pbField.name,
+        type: pbField.type,
+        required: pbField.required || false
+      };
+      if (pbField.options) {
+        field.options = pbField.options;
+      }
+      if (pbField.type === "relation") {
+        field.relation = {
+          collection: pbField.options?.collectionId || "",
+          cascadeDelete: pbField.options?.cascadeDelete || false,
+          maxSelect: pbField.options?.maxSelect,
+          minSelect: pbField.options?.minSelect
+        };
+      }
+      fields.push(field);
+    }
+  }
+  const schema = {
+    name: pbCollection.name,
+    type: pbCollection.type || "base",
+    fields
+  };
+  if (pbCollection.indexes && Array.isArray(pbCollection.indexes)) {
+    schema.indexes = pbCollection.indexes;
+  }
+  const rules = {};
+  if (pbCollection.listRule !== void 0) rules.listRule = pbCollection.listRule;
+  if (pbCollection.viewRule !== void 0) rules.viewRule = pbCollection.viewRule;
+  if (pbCollection.createRule !== void 0) rules.createRule = pbCollection.createRule;
+  if (pbCollection.updateRule !== void 0) rules.updateRule = pbCollection.updateRule;
+  if (pbCollection.deleteRule !== void 0) rules.deleteRule = pbCollection.deleteRule;
+  if (pbCollection.manageRule !== void 0) rules.manageRule = pbCollection.manageRule;
+  if (Object.keys(rules).length > 0) {
+    schema.rules = rules;
+  }
+  return schema;
+}
+function convertPocketBaseMigration(migrationContent) {
+  try {
+    const snapshotMatch = migrationContent.match(/const\s+snapshot\s*=\s*(\[[\s\S]*?\]);/);
+    if (!snapshotMatch) {
+      throw new Error("Could not find snapshot array in migration file");
+    }
+    const snapshotArrayStr = snapshotMatch[1];
+    let snapshotArray;
+    try {
+      snapshotArray = new Function(`return ${snapshotArrayStr}`)();
+    } catch (parseError) {
+      throw new Error(`Failed to parse snapshot array: ${parseError}`);
+    }
+    if (!Array.isArray(snapshotArray)) {
+      throw new Error("Snapshot is not an array");
+    }
+    const collections = /* @__PURE__ */ new Map();
+    for (const pbCollection of snapshotArray) {
+      if (!pbCollection.name) {
+        console.warn("Skipping collection without name");
+        continue;
+      }
+      const schema = convertPocketBaseCollection(pbCollection);
+      collections.set(pbCollection.name, schema);
+    }
+    return {
+      version: SNAPSHOT_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      collections
+    };
+  } catch (error) {
+    throw new SnapshotError(
+      `Failed to convert PocketBase migration: ${error instanceof Error ? error.message : String(error)}`,
+      void 0,
+      "parse",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// src/migration/validation.ts
+function detectCollectionDeletions(diff) {
+  const changes = [];
+  for (const collection of diff.collectionsToDelete) {
+    changes.push({
+      type: "collection_deletion" /* COLLECTION_DELETION */,
+      description: `Delete collection: ${collection.name}`,
+      collection: collection.name,
+      severity: "high",
+      warning: `All data in the "${collection.name}" collection will be permanently deleted.`
+    });
+  }
+  return changes;
+}
+function detectFieldDeletions(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const field of modification.fieldsToRemove) {
+      changes.push({
+        type: "field_deletion" /* FIELD_DELETION */,
+        description: `Delete field: ${modification.collection}.${field.name}`,
+        collection: modification.collection,
+        field: field.name,
+        severity: "high",
+        warning: `All data in the "${field.name}" field of "${modification.collection}" will be permanently deleted.`
+      });
+    }
+  }
+  return changes;
+}
+function detectFieldTypeChanges(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const fieldMod of modification.fieldsToModify) {
+      const typeChange = fieldMod.changes.find((c) => c.property === "type");
+      if (typeChange) {
+        changes.push({
+          type: "field_type_change" /* FIELD_TYPE_CHANGE */,
+          description: `Change field type: ${modification.collection}.${fieldMod.fieldName}`,
+          collection: modification.collection,
+          field: fieldMod.fieldName,
+          details: {
+            oldValue: typeChange.oldValue,
+            newValue: typeChange.newValue
+          },
+          severity: "high",
+          warning: `Changing field type from "${typeChange.oldValue}" to "${typeChange.newValue}" may cause data loss or conversion errors.`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function detectFieldRequiredChanges(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const fieldMod of modification.fieldsToModify) {
+      const requiredChange = fieldMod.changes.find(
+        (c) => c.property === "required" && c.newValue === true && c.oldValue === false
+      );
+      if (requiredChange) {
+        changes.push({
+          type: "field_required_change" /* FIELD_REQUIRED_CHANGE */,
+          description: `Make field required: ${modification.collection}.${fieldMod.fieldName}`,
+          collection: modification.collection,
+          field: fieldMod.fieldName,
+          details: {
+            oldValue: false,
+            newValue: true
+          },
+          severity: "medium",
+          warning: `Making "${fieldMod.fieldName}" required may cause issues with existing records that have null/empty values.`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function detectDestructiveChanges(diff) {
+  const changes = [];
+  changes.push(...detectCollectionDeletions(diff));
+  changes.push(...detectFieldDeletions(diff));
+  changes.push(...detectFieldTypeChanges(diff));
+  changes.push(...detectFieldRequiredChanges(diff));
+  return changes;
+}
+function formatDestructiveChanges(changes) {
+  if (changes.length === 0) {
+    return "No destructive changes detected.";
+  }
+  const lines = [];
+  const highSeverity = changes.filter((c) => c.severity === "high");
+  const mediumSeverity = changes.filter((c) => c.severity === "medium");
+  const lowSeverity = changes.filter((c) => c.severity === "low");
+  if (highSeverity.length > 0) {
+    lines.push("\u{1F534} HIGH SEVERITY CHANGES (Data Loss Risk):");
+    lines.push("");
+    for (const change of highSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
+      if (change.details) {
+        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
+          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (mediumSeverity.length > 0) {
+    lines.push("\u{1F7E1} MEDIUM SEVERITY CHANGES (Potential Issues):");
+    lines.push("");
+    for (const change of mediumSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
+      if (change.details) {
+        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
+          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (lowSeverity.length > 0) {
+    lines.push("\u{1F7E2} LOW SEVERITY CHANGES:");
+    lines.push("");
+    for (const change of lowSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u2139\uFE0F  ${change.warning}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function summarizeDestructiveChanges(changes) {
+  return {
+    total: changes.length,
+    high: changes.filter((c) => c.severity === "high").length,
+    medium: changes.filter((c) => c.severity === "medium").length,
+    low: changes.filter((c) => c.severity === "low").length
+  };
+}
+function requiresForceFlag(changes) {
+  return changes.some((c) => c.severity === "high" || c.severity === "medium");
+}
+var CONFIG_FILE_NAMES = [
+  "pocketbase-migrate.config.js",
+  "pocketbase-migrate.config.mjs",
+  "pocketbase-migrate.config.json",
+  "migrate.config.js",
+  "migrate.config.mjs",
+  "migrate.config.json"
+];
+var DEFAULT_CONFIG5 = {
+  schema: {
+    directory: "src/schema",
+    exclude: ["base.ts", "index.ts", "permissions.ts", "permission-templates.ts"]
+  },
+  migrations: {
+    directory: "pocketbase/pb_migrations",
+    format: "timestamp_description"
+  },
+  diff: {
+    warnOnDelete: true,
+    requireForceForDestructive: true
+  }
+};
+function findConfigFile(directory) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = path4.join(directory, fileName);
+    if (fs4.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function loadJsonConfig(configPath) {
+  try {
+    const content = fs4.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ConfigurationError("Invalid JSON syntax in configuration file", configPath, void 0, error);
+    }
+    throw new ConfigurationError(
+      "Failed to read configuration file",
+      configPath,
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+async function loadJsConfig(configPath) {
+  try {
+    const fileUrl = `file://${configPath}`;
+    const module = await import(fileUrl);
+    return module.default || module;
+  } catch (error) {
+    throw new ConfigurationError(
+      "Failed to load JavaScript configuration file",
+      configPath,
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+async function loadConfigFile(configPath) {
+  if (!fs4.existsSync(configPath)) {
+    return null;
+  }
+  const ext = path4.extname(configPath).toLowerCase();
+  if (ext === ".json") {
+    return loadJsonConfig(configPath);
+  } else if (ext === ".js" || ext === ".mjs") {
+    return loadJsConfig(configPath);
+  } else {
+    throw new ConfigurationError(`Unsupported configuration file format: ${ext}`, configPath, void 0);
+  }
+}
+function mergeConfig4(base, override) {
+  return {
+    schema: { ...base.schema, ...override.schema },
+    migrations: { ...base.migrations, ...override.migrations },
+    diff: { ...base.diff, ...override.diff }
+  };
+}
+function loadConfigFromEnv() {
+  const config = {};
+  if (process.env.MIGRATION_SCHEMA_DIR) {
+    config.schema = { directory: process.env.MIGRATION_SCHEMA_DIR };
+  }
+  if (process.env.MIGRATION_SCHEMA_EXCLUDE) {
+    config.schema = {
+      ...config.schema,
+      exclude: process.env.MIGRATION_SCHEMA_EXCLUDE.split(",").map((s) => s.trim())
+    };
+  }
+  if (process.env.MIGRATION_OUTPUT_DIR) {
+    config.migrations = { directory: process.env.MIGRATION_OUTPUT_DIR };
+  }
+  if (process.env.MIGRATION_REQUIRE_FORCE !== void 0) {
+    config.diff = { requireForceForDestructive: process.env.MIGRATION_REQUIRE_FORCE === "true" };
+  }
+  return config;
+}
+function loadConfigFromArgs(options) {
+  const config = {};
+  if (options.output) {
+    config.migrations = { directory: options.output };
+  }
+  if (options.schemaDir) {
+    config.schema = { directory: options.schemaDir };
+  }
+  return config;
+}
+function validateConfig(config, configPath) {
+  const invalidFields = [];
+  if (typeof config.schema.directory !== "string" || config.schema.directory.trim() === "") {
+    invalidFields.push("schema.directory (must be a non-empty string)");
+  }
+  if (!Array.isArray(config.schema.exclude)) {
+    invalidFields.push("schema.exclude (must be an array of strings)");
+  }
+  if (typeof config.migrations.directory !== "string" || config.migrations.directory.trim() === "") {
+    invalidFields.push("migrations.directory (must be a non-empty string)");
+  }
+  if (typeof config.diff.warnOnDelete !== "boolean") {
+    invalidFields.push("diff.warnOnDelete (must be a boolean)");
+  }
+  if (typeof config.diff.requireForceForDestructive !== "boolean") {
+    invalidFields.push("diff.requireForceForDestructive (must be a boolean)");
+  }
+  if (invalidFields.length > 0) {
+    throw new ConfigurationError("Invalid configuration values", configPath, invalidFields);
+  }
+  const cwd = process.cwd();
+  const possiblePaths = [
+    path4.resolve(cwd, config.schema.directory),
+    path4.resolve(cwd, "shared", config.schema.directory)
+  ];
+  const schemaDir = possiblePaths.find((p) => fs4.existsSync(p));
+  if (!schemaDir) {
+    throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
+      "schema.directory"
+    ]);
+  }
+}
+async function loadConfig(options = {}) {
+  let config = { ...DEFAULT_CONFIG5 };
+  let configFilePath;
+  const cwd = process.cwd();
+  if (options.config) {
+    const explicitPath = path4.resolve(cwd, options.config);
+    if (!fs4.existsSync(explicitPath)) {
+      throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
+    }
+    configFilePath = explicitPath;
+  } else {
+    const searchDirs = [cwd, path4.join(cwd, "shared")];
+    for (const dir of searchDirs) {
+      if (fs4.existsSync(dir)) {
+        const found = findConfigFile(dir);
+        if (found) {
+          configFilePath = found;
+          break;
+        }
+      }
+    }
+  }
+  if (configFilePath) {
+    const fileConfig = await loadConfigFile(configFilePath);
+    if (fileConfig) {
+      config = mergeConfig4(config, fileConfig);
+    }
+  }
+  const envConfig = loadConfigFromEnv();
+  if (Object.keys(envConfig).length > 0) {
+    config = mergeConfig4(config, envConfig);
+  }
+  const argsConfig = loadConfigFromArgs(options);
+  if (Object.keys(argsConfig).length > 0) {
+    config = mergeConfig4(config, argsConfig);
+  }
+  validateConfig(config, configFilePath);
+  return config;
+}
+function getSchemaDirectory(config) {
+  const cwd = process.cwd();
+  const possiblePaths = [
+    path4.resolve(cwd, config.schema.directory),
+    path4.resolve(cwd, "shared", config.schema.directory)
+  ];
+  return possiblePaths.find((p) => fs4.existsSync(p)) || possiblePaths[0];
+}
+function getMigrationsDirectory(config) {
+  const cwd = process.cwd();
+  const possiblePaths = [
+    path4.resolve(cwd, config.migrations.directory),
+    path4.resolve(cwd, "shared", config.migrations.directory)
+  ];
+  return possiblePaths.find((p) => fs4.existsSync(p)) || possiblePaths[0];
+}
+var currentVerbosity = "normal";
+function setVerbosity(level) {
+  currentVerbosity = level;
+}
+function shouldLog(requiredLevel) {
+  const levels = ["quiet", "normal", "verbose"];
+  const currentIndex = levels.indexOf(currentVerbosity);
+  const requiredIndex = levels.indexOf(requiredLevel);
+  return currentIndex >= requiredIndex;
+}
+function createSpinner(text) {
+  if (currentVerbosity === "quiet") {
+    return ora({ text, isSilent: true });
+  }
+  return ora(text);
+}
+function logSuccess(message) {
+  if (shouldLog("normal")) {
+    console.log(chalk.green("\u2713"), message);
+  }
+}
+function logError(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function logWarning(message) {
+  if (shouldLog("normal")) {
+    console.warn(chalk.yellow("\u26A0"), message);
+  }
+}
+function logInfo(message) {
+  if (shouldLog("normal")) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+}
+function logDebug(message) {
+  if (shouldLog("verbose")) {
+    console.log(chalk.gray("\u2699"), chalk.gray(message));
+  }
+}
+function logSection(title) {
+  if (shouldLog("normal")) {
+    console.log();
+    console.log(chalk.bold.cyan(title));
+    console.log(chalk.cyan("\u2500".repeat(title.length)));
+  }
+}
+function formatFieldChange(change) {
+  const oldValue = change.oldValue === null ? "null" : JSON.stringify(change.oldValue);
+  const newValue = change.newValue === null ? "null" : JSON.stringify(change.newValue);
+  return `${change.property}: ${chalk.red(oldValue)} \u2192 ${chalk.green(newValue)}`;
+}
+function formatChangeSummary(diff) {
+  const lines = [];
+  const totalCollectionsToCreate = diff.collectionsToCreate.length;
+  const totalCollectionsToDelete = diff.collectionsToDelete.length;
+  const totalCollectionsToModify = diff.collectionsToModify.length;
+  const totalChanges = totalCollectionsToCreate + totalCollectionsToDelete + totalCollectionsToModify;
+  if (totalChanges === 0) {
+    return chalk.gray("No changes detected");
+  }
+  lines.push(chalk.bold(`Found ${totalChanges} collection change(s):`));
+  lines.push("");
+  if (totalCollectionsToCreate > 0) {
+    lines.push(chalk.green.bold(`\u2713 ${totalCollectionsToCreate} collection(s) to create:`));
+    for (const collection of diff.collectionsToCreate) {
+      lines.push(chalk.green(`  + ${collection.name} (${collection.type})`));
+      lines.push(chalk.gray(`    ${collection.fields.length} field(s)`));
+    }
+    lines.push("");
+  }
+  if (totalCollectionsToDelete > 0) {
+    lines.push(chalk.red.bold(`\u2717 ${totalCollectionsToDelete} collection(s) to delete:`));
+    for (const collection of diff.collectionsToDelete) {
+      lines.push(chalk.red(`  - ${collection.name}`));
+    }
+    lines.push("");
+  }
+  if (totalCollectionsToModify > 0) {
+    lines.push(chalk.yellow.bold(`\u26A1 ${totalCollectionsToModify} collection(s) to modify:`));
+    for (const modification of diff.collectionsToModify) {
+      lines.push(chalk.yellow(`  ~ ${modification.collection}`));
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(chalk.green(`    + ${modification.fieldsToAdd.length} field(s) to add:`));
+        for (const field of modification.fieldsToAdd) {
+          lines.push(chalk.green(`      + ${field.name} (${field.type})`));
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(chalk.red(`    - ${modification.fieldsToRemove.length} field(s) to remove:`));
+        for (const field of modification.fieldsToRemove) {
+          lines.push(chalk.red(`      - ${field.name}`));
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(chalk.yellow(`    ~ ${modification.fieldsToModify.length} field(s) to modify:`));
+        for (const fieldMod of modification.fieldsToModify) {
+          lines.push(chalk.yellow(`      ~ ${fieldMod.fieldName}`));
+          for (const change of fieldMod.changes) {
+            lines.push(chalk.gray(`        ${formatFieldChange(change)}`));
+          }
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(chalk.green(`    + ${modification.indexesToAdd.length} index(es) to add`));
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(chalk.red(`    - ${modification.indexesToRemove.length} index(es) to remove`));
+      }
+      if (modification.rulesToUpdate.length > 0) {
+        lines.push(chalk.yellow(`    ~ ${modification.rulesToUpdate.length} rule(s) to update`));
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+async function withProgress(message, operation) {
+  const spinner = createSpinner(message).start();
+  try {
+    const result = await operation();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+function logKeyValue(key, value, indent = 2) {
+  if (shouldLog("normal")) {
+    const padding = " ".repeat(indent);
+    console.log(`${padding}${chalk.gray(key + ":")} ${value}`);
+  }
+}
+function logTable(headers, rows) {
+  if (!shouldLog("normal")) return;
+  const widths = headers.map((h, i) => {
+    const maxRowWidth = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxRowWidth);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(chalk.bold(headerLine));
+  console.log(chalk.gray("\u2500".repeat(headerLine.length)));
+  for (const row of rows) {
+    const rowLine = row.map((cell, i) => (cell || "").padEnd(widths[i])).join("  ");
+    console.log(rowLine);
+  }
+}
+function formatStatusJson(output) {
+  return JSON.stringify(output, null, 2);
+}
+
+// src/cli/commands/generate.ts
+function hasChanges2(diff) {
+  return diff.collectionsToCreate.length > 0 || diff.collectionsToDelete.length > 0 || diff.collectionsToModify.length > 0;
+}
+function handleDestructiveChanges(diff, config, force) {
+  const destructiveChanges = detectDestructiveChanges(diff);
+  if (destructiveChanges.length === 0) {
+    return true;
+  }
+  logSection("\u26A0\uFE0F  Destructive Changes Detected");
+  console.log();
+  console.log(formatDestructiveChanges(destructiveChanges));
+  const summary = summarizeDestructiveChanges(destructiveChanges);
+  console.log("Summary:");
+  console.log(`  Total: ${summary.total} destructive change(s)`);
+  if (summary.high > 0) {
+    console.log(`  High Severity: ${summary.high}`);
+  }
+  if (summary.medium > 0) {
+    console.log(`  Medium Severity: ${summary.medium}`);
+  }
+  if (summary.low > 0) {
+    console.log(`  Low Severity: ${summary.low}`);
+  }
+  console.log();
+  const forceRequired = config.diff.requireForceForDestructive && requiresForceFlag(destructiveChanges);
+  if (forceRequired && !force) {
+    logError("Destructive changes require the --force flag to proceed.");
+    console.log();
+    logInfo("To proceed with these changes, run the command again with --force:");
+    console.log("  yarn migrate:generate --force");
+    console.log();
+    logWarning("\u26A0\uFE0F  WARNING: Using --force will apply these changes and may result in data loss!");
+    return false;
+  }
+  if (force) {
+    logWarning("Proceeding with destructive changes (--force flag provided)");
+    console.log();
+  }
+  return true;
+}
+async function executeGenerate(options) {
+  try {
+    const parentOpts = options.parent?.opts?.() || {};
+    if (parentOpts.verbose) {
+      setVerbosity("verbose");
+    } else if (parentOpts.quiet) {
+      setVerbosity("quiet");
+    }
+    logDebug("Starting migration generation...");
+    logDebug(`Options: ${JSON.stringify(options, null, 2)}`);
+    const config = await loadConfig(options);
+    const schemaDir = getSchemaDirectory(config);
+    const migrationsDir = getMigrationsDirectory(config);
+    logSection("\u{1F50D} Analyzing Schema");
+    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(schemaDir));
+    logSuccess(`Found ${currentSchema.collections.size} collection(s)`);
+    logInfo("Loading previous snapshot...");
+    const previousSnapshot = loadSnapshotIfExists({
+      migrationsPath: migrationsDir,
+      workspaceRoot: process.cwd()
+    });
+    if (!previousSnapshot) {
+      logInfo("No previous snapshot found - treating as empty database (first-time generation)");
+    } else {
+      logSuccess("Loaded previous snapshot as base reference");
+    }
+    logSection("\u{1F4CA} Comparing Schemas");
+    const diff = compare(currentSchema, previousSnapshot);
+    if (!hasChanges2(diff)) {
+      logInfo("No changes detected");
+      console.log();
+      logSuccess("Schema is up to date!");
+      return;
+    }
+    console.log();
+    console.log(formatChangeSummary(diff));
+    if (!handleDestructiveChanges(diff, config, options.force)) {
+      process.exit(1);
+    }
+    logSection("\u{1F4DD} Generating Migration");
+    const migrationPath = await withProgress(
+      "Creating migration file...",
+      () => Promise.resolve(generate(diff, migrationsDir))
+    );
+    logSuccess(`Migration file created: ${path4.basename(migrationPath)}`);
+    logSection("\u2705 Next Steps");
+    console.log();
+    console.log("  1. Review the generated migration file:");
+    console.log(`     ${migrationPath}`);
+    console.log();
+    console.log("  2. Apply the migration by running PocketBase:");
+    console.log("     yarn pb");
+    console.log();
+    console.log("  Or apply migrations manually:");
+    console.log("     cd pb && ./pocketbase migrate up");
+    console.log();
+  } catch (error) {
+    if (error instanceof SchemaParsingError) {
+      logError("Schema Parsing Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Make sure your schema files are valid Zod schemas");
+      console.log('  \u2022 Run "yarn build" in the shared workspace to compile TypeScript files');
+      console.log('  \u2022 Check that schema files export schemas ending with "Schema" or "InputSchema"');
+    } else if (error instanceof SnapshotError) {
+      logError("Snapshot Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check that the snapshot file is not corrupted");
+      console.log("  \u2022 Verify file permissions for the snapshot file");
+      console.log("  \u2022 If this is the first run, this error should not occur");
+    } else if (error instanceof MigrationGenerationError) {
+      logError("Migration Generation Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check that the migration directory exists and is writable");
+      console.log("  \u2022 Verify you have sufficient disk space");
+      console.log("  \u2022 Check file permissions for the migration directory");
+    } else if (error instanceof FileSystemError) {
+      logError("File System Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check file and directory permissions");
+      console.log("  \u2022 Verify you have sufficient disk space");
+      console.log("  \u2022 Ensure the paths are correct and accessible");
+    } else if (error instanceof ConfigurationError) {
+      logError("Configuration Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check your configuration file syntax");
+      console.log("  \u2022 Verify all paths are correct and accessible");
+      console.log("  \u2022 Run with --verbose flag for more details");
+    } else {
+      logError(`Failed to generate migration: ${error}`);
+      if (error instanceof Error && error.stack) {
+        console.error();
+        console.error(error.stack);
+      }
+    }
+    console.error();
+    process.exit(1);
+  }
+}
+function createGenerateCommand() {
+  return new Command("generate").description("Generate a migration from schema changes").option("-o, --output <directory>", "Output directory for migration files").option("-f, --force", "Force generation even with destructive changes", false).option("--dry-run", "Show what would be generated without creating files", false).option("--schema-dir <directory>", "Directory containing Zod schema files").addHelpText(
+    "after",
+    `
+Examples:
+  $ pocketbase-migrate generate                    Generate migration from schema changes
+  $ pocketbase-migrate generate --force            Force generation with destructive changes
+  $ pocketbase-migrate generate --dry-run          Preview changes without generating files
+  $ pocketbase-migrate generate -o ./migrations    Specify output directory
+`
+  ).action(executeGenerate);
+}
+function hasChanges3(diff) {
+  return diff.collectionsToCreate.length > 0 || diff.collectionsToDelete.length > 0 || diff.collectionsToModify.length > 0;
+}
+function hasDestructiveChanges(diff) {
+  const { destructive } = categorizeChangesBySeverity(diff);
+  return destructive.length > 0;
+}
+function createStatusOutput(status, currentCount, snapshotCount, diff) {
+  return {
+    status,
+    collections: {
+      current: currentCount,
+      snapshot: snapshotCount
+    },
+    changes: {
+      create: diff?.collectionsToCreate.length ?? 0,
+      delete: diff?.collectionsToDelete.length ?? 0,
+      modify: diff?.collectionsToModify.length ?? 0
+    },
+    destructive: diff ? hasDestructiveChanges(diff) : false
+  };
+}
+function displayDestructiveChangesSummary(diff) {
+  const { destructive, nonDestructive } = categorizeChangesBySeverity(diff);
+  if (destructive.length > 0) {
+    logSection("\u26A0\uFE0F  Destructive Changes");
+    console.log();
+    for (const change of destructive) {
+      console.log(chalk.red(`  ${change}`));
+    }
+    console.log();
+  }
+  if (nonDestructive.length > 0) {
+    logSection("\u2713 Non-Destructive Changes");
+    console.log();
+    for (const change of nonDestructive) {
+      console.log(chalk.green(`  ${change}`));
+    }
+    console.log();
+  }
+}
+function displayChangeTable(diff) {
+  const rows = [];
+  for (const collection of diff.collectionsToCreate) {
+    rows.push([
+      chalk.green("+"),
+      collection.name,
+      collection.type,
+      `${collection.fields.length} fields`,
+      chalk.green("Create")
+    ]);
+  }
+  for (const collection of diff.collectionsToDelete) {
+    rows.push([chalk.red("-"), collection.name, collection.type || "base", "-", chalk.red("Delete")]);
+  }
+  for (const mod of diff.collectionsToModify) {
+    const changes = [];
+    if (mod.fieldsToAdd.length > 0) changes.push(`+${mod.fieldsToAdd.length} fields`);
+    if (mod.fieldsToRemove.length > 0) changes.push(`-${mod.fieldsToRemove.length} fields`);
+    if (mod.fieldsToModify.length > 0) changes.push(`~${mod.fieldsToModify.length} fields`);
+    if (mod.indexesToAdd.length > 0) changes.push(`+${mod.indexesToAdd.length} indexes`);
+    if (mod.indexesToRemove.length > 0) changes.push(`-${mod.indexesToRemove.length} indexes`);
+    if (mod.rulesToUpdate.length > 0) changes.push(`~${mod.rulesToUpdate.length} rules`);
+    rows.push([chalk.yellow("~"), mod.collection, "-", changes.join(", ") || "No changes", chalk.yellow("Modify")]);
+  }
+  if (rows.length > 0) {
+    logTable(["", "Collection", "Type", "Changes", "Action"], rows);
+  }
+}
+async function executeStatus(options) {
+  const isJsonMode = options.json === true;
+  try {
+    if (isJsonMode) {
+      setVerbosity("quiet");
+    } else {
+      const parentOpts = options.parent?.opts?.() || {};
+      if (parentOpts.verbose) {
+        setVerbosity("verbose");
+      } else if (parentOpts.quiet) {
+        setVerbosity("quiet");
+      }
+    }
+    logDebug("Checking migration status...");
+    logDebug(`Options: ${JSON.stringify(options, null, 2)}`);
+    const config = await loadConfig(options);
+    const schemaDir = getSchemaDirectory(config);
+    const migrationsDir = getMigrationsDirectory(config);
+    logSection("\u{1F50D} Checking Migration Status");
+    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(schemaDir));
+    logSuccess(`Found ${currentSchema.collections.size} collection(s) in schema`);
+    logInfo("Loading previous snapshot...");
+    const previousSnapshot = loadSnapshotIfExists({
+      migrationsPath: migrationsDir,
+      workspaceRoot: process.cwd()
+    });
+    if (!previousSnapshot) {
+      if (isJsonMode) {
+        const output = createStatusOutput("first-time-setup", currentSchema.collections.size, 0);
+        console.log(formatStatusJson(output));
+        return;
+      }
+      logSection("\u{1F195} First-Time Setup Detected");
+      console.log();
+      logInfo("No previous snapshot found. This appears to be a first-time setup.");
+      console.log();
+      logKeyValue("Collections in schema", String(currentSchema.collections.size));
+      console.log();
+      logInfo('Run "pocketbase-migrate generate" to create the initial migration.');
+      return;
+    }
+    logSuccess(`Loaded snapshot with ${previousSnapshot.collections.size} collection(s)`);
+    logSection("\u{1F4CA} Schema Comparison");
+    const diff = compare(currentSchema, previousSnapshot);
+    if (!hasChanges3(diff)) {
+      if (isJsonMode) {
+        const output = createStatusOutput(
+          "up-to-date",
+          currentSchema.collections.size,
+          previousSnapshot.collections.size,
+          diff
+        );
+        console.log(formatStatusJson(output));
+        return;
+      }
+      console.log();
+      logSuccess("\u2713 Schema is in sync with snapshot");
+      logInfo("No pending changes detected");
+      console.log();
+      logKeyValue("Collections", String(currentSchema.collections.size));
+      return;
+    }
+    if (isJsonMode) {
+      const output = createStatusOutput(
+        "changes-pending",
+        currentSchema.collections.size,
+        previousSnapshot.collections.size,
+        diff
+      );
+      console.log(formatStatusJson(output));
+      return;
+    }
+    console.log();
+    console.log(formatChangeSummary(diff));
+    logDebug("Detailed change table:");
+    displayChangeTable(diff);
+    displayDestructiveChangesSummary(diff);
+    logSection("\u{1F4DD} Next Steps");
+    console.log();
+    console.log("  To generate a migration for these changes, run:");
+    console.log(chalk.cyan("     pocketbase-migrate generate"));
+    console.log();
+    const { destructive } = categorizeChangesBySeverity(diff);
+    if (destructive.length > 0) {
+      console.log(chalk.yellow("  \u26A0\uFE0F  Destructive changes detected. Use --force flag when generating:"));
+      console.log(chalk.cyan("     pocketbase-migrate generate --force"));
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof SchemaParsingError) {
+      logError("Schema Parsing Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Make sure your schema files are valid Zod schemas");
+      console.log('  \u2022 Check that schema files export schemas ending with "Schema" or "InputSchema"');
+    } else if (error instanceof SnapshotError) {
+      logError("Snapshot Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check that the snapshot file is not corrupted");
+      console.log("  \u2022 Verify file permissions for the snapshot file");
+    } else if (error instanceof ConfigurationError) {
+      logError("Configuration Error");
+      console.error();
+      console.error(error.getDetailedMessage());
+      console.error();
+      logInfo("Suggestions:");
+      console.log("  \u2022 Check your configuration file syntax");
+      console.log("  \u2022 Verify all paths are correct and accessible");
+    } else {
+      logError(`Failed to check status: ${error}`);
+      if (error instanceof Error && error.stack) {
+        console.error(error.stack);
+      }
+    }
+    process.exit(1);
+  }
+}
+function createStatusCommand() {
+  return new Command("status").description("Show current migration status without generating files").option("--schema-dir <directory>", "Directory containing Zod schema files").option("--json", "Output status as JSON for programmatic use", false).addHelpText(
+    "after",
+    `
+Examples:
+  $ pocketbase-migrate status              Check for pending schema changes
+  $ pocketbase-migrate status --json       Output status as JSON
+  $ pocketbase-migrate status --verbose    Show detailed status information
+`
+  ).action(executeStatus);
+}
+
+// src/cli/migrate.ts
+var VERSION = "0.1.0";
+function displayBanner() {
+  console.log();
+  console.log(chalk.cyan.bold("  PocketBase Zod Migration Tool"));
+  console.log(chalk.gray(`  Version ${VERSION}`));
+  console.log();
+}
+var program = new Command();
+program.name("pocketbase-migrate").description(
+  "Schema-driven PocketBase migration tool\n\nGenerate type-safe migrations from Zod schemas for PocketBase applications."
+).version(VERSION, "-v, --version", "Output the current version").option("-c, --config <path>", "Path to configuration file").option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--no-color", "Disable colored output").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.color === false) {
+    chalk.level = 0;
+  }
+  if (!opts.quiet) {
+    displayBanner();
+  }
+});
+program.addCommand(createGenerateCommand());
+program.addCommand(createStatusCommand());
+program.addHelpText(
+  "after",
+  `
+${chalk.bold("Examples:")}
+  $ pocketbase-migrate status              Check for pending schema changes
+  $ pocketbase-migrate generate            Generate migration from schema changes
+  $ pocketbase-migrate generate --force    Generate migration with destructive changes
+  $ pocketbase-migrate --help              Show this help message
+
+${chalk.bold("Configuration:")}
+  The tool looks for configuration in the following order:
+  1. CLI arguments (highest priority)
+  2. Environment variables (MIGRATION_SCHEMA_DIR, MIGRATION_OUTPUT_DIR, etc.)
+  3. Configuration file (migrate.config.js)
+  4. Default values
+
+${chalk.bold("Documentation:")}
+  For more information, visit: https://github.com/dastron/pocketbase-zod-schema
+`
+);
+program.exitOverride((err) => {
+  const anyErr = err;
+  if (anyErr?.code === "commander.help" || anyErr?.code === "commander.helpDisplayed") {
+    process.exit(0);
+  }
+  if (anyErr?.code === "commander.version") {
+    process.exit(0);
+  }
+  if (typeof anyErr?.exitCode === "number") {
+    process.exit(anyErr.exitCode);
+  }
+  process.exit(1);
+});
+if (process.argv.length === 2) {
+  displayBanner();
+  program.help();
+}
+program.parse(process.argv);
+//# sourceMappingURL=migrate.js.map
+//# sourceMappingURL=migrate.js.map