pocketbase-zod-schema 0.1.2

package/dist/index.js

@@ -0,0 +1,4726 @@
+import { z } from 'zod';
+import * as fs2 from 'fs';
+import * as path4 from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// src/enums.ts
+var StatusEnum = z.enum([
+  "draft",
+  // Initial proposal stage (RequestDraft, ProjectDraft)
+  "active",
+  // Work in progress
+  "complete",
+  // Fully completed project
+  "fail"
+  // Failed project at any stage
+]);
+var baseSchema = {
+  id: z.string().describe("unique id"),
+  collectionId: z.string().describe("collection id"),
+  collectionName: z.string().describe("collection name"),
+  expand: z.record(z.any()).describe("expandable fields")
+};
+var baseSchemaWithTimestamps = {
+  ...baseSchema,
+  created: z.string().describe("creation timestamp"),
+  updated: z.string().describe("last update timestamp")
+};
+var baseImageFileSchema = {
+  ...baseSchema,
+  thumbnailURL: z.string().optional(),
+  imageFiles: z.array(z.string())
+};
+var inputImageFileSchema = {
+  imageFiles: z.array(z.instanceof(File))
+};
+var omitImageFilesSchema = {
+  imageFiles: true
+};
+function textField(options) {
+  let schema = z.string();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  if (options?.pattern !== void 0) schema = schema.regex(options.pattern);
+  return schema;
+}
+function emailField() {
+  return z.string().email();
+}
+function urlField() {
+  return z.string().url();
+}
+function numberField(options) {
+  let schema = z.number();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+function boolField() {
+  return z.boolean();
+}
+function dateField() {
+  return z.date();
+}
+function selectField(values) {
+  return z.enum(values);
+}
+function jsonField(schema) {
+  return schema ?? z.record(z.any());
+}
+function fileField() {
+  return z.instanceof(File);
+}
+function filesField(options) {
+  let schema = z.array(z.instanceof(File));
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+function relationField() {
+  return z.string();
+}
+function relationsField(options) {
+  let schema = z.array(z.string());
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+function editorField() {
+  return z.string();
+}
+function geoPointField() {
+  return z.object({
+    lon: z.number(),
+    lat: z.number()
+  });
+}
+function withPermissions(schema, config) {
+  const metadata = {
+    permissions: config
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function withIndexes(schema, indexes) {
+  let existingMetadata = {};
+  if (schema.description) {
+    try {
+      existingMetadata = JSON.parse(schema.description);
+    } catch {
+    }
+  }
+  const metadata = {
+    ...existingMetadata,
+    indexes
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+
+// 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
+  };
+}
+function isTemplateConfig(config) {
+  return "template" in config;
+}
+function isPermissionSchema(config) {
+  return "listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config;
+}
+function validatePermissionConfig(config, isAuthCollection2 = false) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  let permissions;
+  if (isTemplateConfig(config)) {
+    if (config.template === "owner-only" && !config.ownerField) {
+      result.warnings.push("owner-only template without ownerField specified - using default 'User'");
+    }
+    if (config.template === "admin-only" && !config.roleField) {
+      result.warnings.push("admin-only template without roleField specified - using default 'role'");
+    }
+    permissions = resolveTemplate(config);
+  } else {
+    permissions = config;
+  }
+  if (permissions.manageRule !== void 0 && !isAuthCollection2) {
+    result.errors.push("manageRule is only valid for auth collections");
+    result.valid = false;
+  }
+  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
+  if (isAuthCollection2) {
+    ruleTypes.push("manageRule");
+  }
+  for (const ruleType of ruleTypes) {
+    const rule = permissions[ruleType];
+    if (rule !== void 0 && rule !== null && rule !== "") {
+      const ruleValidation = validateRuleExpression(rule);
+      if (!ruleValidation.valid) {
+        result.errors.push(`${ruleType}: ${ruleValidation.errors.join(", ")}`);
+        result.valid = false;
+      }
+      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
+    }
+  }
+  return result;
+}
+function validateRuleExpression(expression) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  if (expression === null || expression === "") {
+    return result;
+  }
+  let parenCount = 0;
+  for (const char of expression) {
+    if (char === "(") parenCount++;
+    if (char === ")") parenCount--;
+    if (parenCount < 0) {
+      result.errors.push("Unbalanced parentheses");
+      result.valid = false;
+      return result;
+    }
+  }
+  if (parenCount !== 0) {
+    result.errors.push("Unbalanced parentheses");
+    result.valid = false;
+  }
+  if (expression.includes("==")) {
+    result.warnings.push("Use '=' instead of '==' for equality comparison");
+  }
+  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;
+    }
+  }
+  return result;
+}
+function createPermissions(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
+  };
+}
+function mergePermissions(...schemas) {
+  const merged = {
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null,
+    manageRule: null
+  };
+  for (const schema of schemas) {
+    if (schema.listRule !== void 0) merged.listRule = schema.listRule;
+    if (schema.viewRule !== void 0) merged.viewRule = schema.viewRule;
+    if (schema.createRule !== void 0) merged.createRule = schema.createRule;
+    if (schema.updateRule !== void 0) merged.updateRule = schema.updateRule;
+    if (schema.deleteRule !== void 0) merged.deleteRule = schema.deleteRule;
+    if (schema.manageRule !== void 0) merged.manageRule = schema.manageRule;
+  }
+  return merged;
+}
+var ProjectInputSchema = z.object({
+  // Required fields
+  title: z.string(),
+  content: z.string(),
+  status: StatusEnum,
+  summary: z.string().optional(),
+  User: z.string().nonempty("User ID is missing"),
+  SubscriberUsers: z.array(z.string())
+}).extend(inputImageFileSchema);
+var ProjectSchema = withPermissions(
+  ProjectInputSchema.omit(omitImageFilesSchema).extend(baseImageFileSchema),
+  {
+    template: "owner-only",
+    ownerField: "User",
+    customRules: {
+      // Override list rule to allow authenticated users to see all projects
+      listRule: '@request.auth.id != ""',
+      // Allow viewing if user is owner OR a subscriber
+      viewRule: '@request.auth.id != "" && (User = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
+    }
+  }
+);
+var UserInputSchema = z.object({
+  name: z.string().min(2, "Name must be longer").optional(),
+  email: z.string().email(),
+  password: z.string().min(8, "Password must be at least 8 characters"),
+  passwordConfirm: z.string(),
+  avatar: z.instanceof(File).optional()
+});
+var UserDatabaseSchema = z.object({
+  name: z.string().min(2, "Name must be longer").optional(),
+  email: z.string().email(),
+  password: z.string().min(8, "Password must be at least 8 characters"),
+  avatar: z.instanceof(File).optional()
+});
+var UserSchema = withIndexes(
+  withPermissions(UserDatabaseSchema.extend(baseSchema), {
+    // Users can list other users (for mentions, user search, etc.)
+    listRule: "id = @request.auth.id",
+    // Users can view their own profile
+    viewRule: "id = @request.auth.id",
+    // Anyone can create an account (sign up)
+    createRule: "",
+    // Users can only update their own profile
+    updateRule: "id = @request.auth.id",
+    // Users can only delete their own account
+    deleteRule: "id = @request.auth.id",
+    // Users can only manage their own account (change email, password, etc.)
+    manageRule: "id = @request.auth.id"
+  }),
+  [
+    // Email should be unique for authentication
+    "CREATE UNIQUE INDEX idx_users_email ON users (email)",
+    // Index on name for user search and sorting
+    "CREATE INDEX idx_users_name ON users (name)"
+  ]
+);
+var BaseMutator = class {
+  pb;
+  // Define a default property that subclasses will override
+  options = {
+    expand: [],
+    filter: [],
+    sort: []
+  };
+  constructor(pb, options) {
+    this.pb = pb;
+    this.initializeOptions();
+    if (options) {
+      this.overrideOptions(options);
+    }
+  }
+  initializeOptions() {
+    this.options = this.setDefaults();
+  }
+  /**
+   * Initialize options with class-specific defaults
+   * Subclasses should override this instead of directly setting options
+   */
+  setDefaults() {
+    return {
+      expand: [],
+      filter: [],
+      sort: []
+    };
+  }
+  /**
+   * Merge provided options with current options
+   */
+  overrideOptions(newOptions) {
+    if (newOptions.expand !== void 0) {
+      this.options.expand = newOptions.expand;
+    }
+    if (newOptions.filter !== void 0) {
+      this.options.filter = newOptions.filter;
+    }
+    if (newOptions.sort !== void 0) {
+      this.options.sort = newOptions.sort;
+    }
+  }
+  toSnakeCase(str) {
+    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  }
+  /**
+   * Create a new entity
+   */
+  async create(input) {
+    try {
+      const data = await this.validateInput(input);
+      const record = await this.entityCreate(data);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Update an existing entity
+   */
+  async update(id, input) {
+    try {
+      const record = await this.entityUpdate(id, input);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Create or update entity (upsert)
+   */
+  async upsert(input) {
+    if (input?.id) {
+      return await this.update(input.id, input);
+    }
+    return await this.create(input);
+  }
+  /**
+   * Get entity by ID
+   */
+  async getById(id, expand) {
+    try {
+      const record = await this.entityGetById(id, expand);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
+  /**
+   * Get first entity by filter
+   */
+  async getFirstByFilter(filter, expand, sort) {
+    try {
+      const record = await this.entityGetFirstByFilter(filter, expand, sort);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
+  /**
+   * Get list of entities
+   */
+  async getList(page = 1, perPage = 100, filter, sort, expand) {
+    try {
+      const result = await this.entityGetList(page, perPage, filter, sort, expand);
+      return await this.processListResult(result);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Delete entity by ID
+   */
+  async delete(id) {
+    try {
+      return await this.entityDelete(id);
+    } catch (error) {
+      return this.handleError(error, { returnValue: false });
+    }
+  }
+  /**
+   * Process a single record before returning it
+   * Can be overridden to handle special cases like mapped entities
+   */
+  async processRecord(record) {
+    return record;
+  }
+  /**
+   * Process a list result before returning it
+   * Can be overridden to handle special cases like mapped entities
+   */
+  async processListResult(result) {
+    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
+    return {
+      ...result,
+      items: processedItems
+    };
+  }
+  /**
+   * Prepare expand parameter
+   * Combines default expands with provided expands
+   */
+  prepareExpand(expand) {
+    if (!this.options.expand.length && !expand) {
+      return void 0;
+    }
+    let expandArray = [...this.options.expand];
+    if (expand) {
+      if (typeof expand === "string") {
+        expandArray = expandArray.concat(expand.split(",").map((e) => e.trim()));
+      } else {
+        expandArray = expandArray.concat(expand);
+      }
+    }
+    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
+    if (!uniqueExpands.length) {
+      return void 0;
+    }
+    return uniqueExpands.join(",");
+  }
+  /**
+   * Prepare filter parameter
+   * Combines default filters with provided filters
+   */
+  prepareFilter(filter) {
+    if (!this.options.filter.length && !filter) {
+      return void 0;
+    }
+    let filterArray = [...this.options.filter];
+    if (filter) {
+      if (typeof filter === "string") {
+        if (filter) filterArray.push(filter);
+      } else {
+        filterArray = filterArray.concat(filter);
+      }
+    }
+    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
+    if (!validFilters.length) {
+      return void 0;
+    }
+    return validFilters.join("&&");
+  }
+  /**
+   * Prepare sort parameter
+   * Uses provided sort or falls back to default sort
+   */
+  prepareSort(sort) {
+    if (sort && sort !== "") {
+      return sort;
+    }
+    if (this.options.sort.length) {
+      const validSorts = this.options.sort.filter((s) => s !== "" && s !== void 0);
+      if (validSorts.length) {
+        return validSorts.join(",");
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Perform the actual create operation
+   */
+  async entityCreate(data) {
+    return await this.getCollection().create(data);
+  }
+  /**
+   * Perform the actual update operation
+   */
+  async entityUpdate(id, data) {
+    return await this.getCollection().update(id, data);
+  }
+  /**
+   * Perform the actual getById operation
+   */
+  async entityGetById(id, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return await this.getCollection().getOne(id, options);
+  }
+  /**
+   * Perform the actual getFirstByFilter operation
+   */
+  async entityGetFirstByFilter(filter, expand, sort) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getFirstListItem(finalFilter || "", options);
+  }
+  /**
+   * Perform the actual getList operation
+   * Returns a list result with items of type T
+   */
+  async entityGetList(page, perPage, filter, sort, expand) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalFilter) options.filter = finalFilter;
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getList(page, perPage, options);
+  }
+  /**
+   * Perform the actual delete operation
+   */
+  async entityDelete(id) {
+    await this.getCollection().delete(id);
+    return true;
+  }
+  /**
+   * Error handler for common errors
+   * @param error The error to handle
+   * @param options Handler options
+   * @returns The value to return if the error is handled, or throws if not handled
+   */
+  handleError(error, options = { logError: true }) {
+    const { allowNotFound = false, returnValue, logError: logError2 = true } = options;
+    if (logError2) {
+      console.error(`Error in ${this.constructor.name}:`, error);
+    }
+    if (allowNotFound && this.isNotFoundError(error)) {
+      return null;
+    }
+    if (returnValue !== void 0) {
+      return returnValue;
+    }
+    throw error;
+  }
+  /**
+   * Check if an error is a "not found" error
+   */
+  isNotFoundError(error) {
+    return error instanceof Error && (error.message.includes("404") || error.message.toLowerCase().includes("not found"));
+  }
+  /**
+   * Standard error handling wrapper (legacy method, consider using handleError instead)
+   */
+  errorWrapper(error) {
+    console.error(`Error in ${this.constructor.name}:`, error);
+    throw error;
+  }
+  /**
+   * Subscribe to changes on a specific record
+   * @param id The ID of the record to subscribe to
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
+   */
+  async subscribeToRecord(id, callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe(id, callback, options);
+  }
+  /**
+   * Subscribe to changes on the entire collection
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
+   */
+  async subscribeToCollection(callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe("*", callback, options);
+  }
+  /**
+   * Unsubscribe from a specific record's changes
+   * @param id The ID of the record to unsubscribe from
+   */
+  unsubscribeFromRecord(id) {
+    this.getCollection().unsubscribe(id);
+  }
+  /**
+   * Unsubscribe from collection-wide changes
+   */
+  unsubscribeFromCollection() {
+    this.getCollection().unsubscribe("*");
+  }
+  /**
+   * Unsubscribe from all subscriptions in this collection
+   */
+  unsubscribeAll() {
+    this.getCollection().unsubscribe();
+  }
+};
+
+// src/mutator/userMutator.ts
+var UserMutator = class extends BaseMutator {
+  setDefaults() {
+    return {
+      expand: [],
+      filter: [],
+      sort: ["-updated"]
+    };
+  }
+  getCollection() {
+    return this.pb.collection("Projects");
+  }
+  async validateInput(input) {
+    return UserInputSchema.parse(input);
+  }
+};
+
+// 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("");
+  }
+};
+var CLIUsageError = class _CLIUsageError extends MigrationError {
+  command;
+  suggestion;
+  constructor(message, command, suggestion) {
+    super(message);
+    this.name = "CLIUsageError";
+    this.command = command;
+    this.suggestion = suggestion;
+    Object.setPrototypeOf(this, _CLIUsageError.prototype);
+  }
+  /**
+   * Creates a formatted error message with usage suggestions
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.command) {
+      parts.push(`
+Command: ${this.command}`);
+    }
+    if (this.suggestion) {
+      parts.push(`
+Suggestion: ${this.suggestion}`);
+    }
+    return parts.join("");
+  }
+};
+
+// 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 singularize(plural) {
+  for (const [singular, pluralForm] of Object.entries(SPECIAL_CASES)) {
+    if (pluralForm === plural) {
+      return singular;
+    }
+  }
+  const lower = plural.toLowerCase();
+  if (lower.endsWith("ies") && plural.length > 3) {
+    return plural.slice(0, -3) + "y";
+  }
+  if (lower.endsWith("ves")) {
+    return plural.slice(0, -3) + "fe";
+  }
+  if (/(?:ses|shes|ches|xes|zes)$/.test(lower)) {
+    return plural.slice(0, -2);
+  }
+  if (lower.endsWith("s") && plural.length > 1) {
+    return plural.slice(0, -1);
+  }
+  return plural;
+}
+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;
+}
+var POCKETBASE_FIELD_TYPES = [
+  "text",
+  "email",
+  "url",
+  "number",
+  "bool",
+  "date",
+  "select",
+  "relation",
+  "file",
+  "json",
+  "editor",
+  "geoPoint",
+  "autodate"
+];
+var FIELD_TYPE_INFO = {
+  text: {
+    type: "text",
+    description: "Plain text field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  email: {
+    type: "email",
+    description: "Email address field with validation",
+    zodTypes: ["ZodString with email()"],
+    supportsMultiple: false
+  },
+  url: {
+    type: "url",
+    description: "URL field with validation",
+    zodTypes: ["ZodString with url()"],
+    supportsMultiple: false
+  },
+  editor: {
+    type: "editor",
+    description: "Rich text editor field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  number: {
+    type: "number",
+    description: "Numeric field (integer or float)",
+    zodTypes: ["ZodNumber"],
+    supportsMultiple: false
+  },
+  bool: {
+    type: "bool",
+    description: "Boolean field",
+    zodTypes: ["ZodBoolean"],
+    supportsMultiple: false
+  },
+  date: {
+    type: "date",
+    description: "Date/datetime field",
+    zodTypes: ["ZodDate", "ZodString with datetime format"],
+    supportsMultiple: false
+  },
+  autodate: {
+    type: "autodate",
+    description: "Auto-managed date field (created/updated)",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  select: {
+    type: "select",
+    description: "Single or multiple select from predefined values",
+    zodTypes: ["ZodEnum", "ZodArray<ZodEnum>"],
+    supportsMultiple: true
+  },
+  relation: {
+    type: "relation",
+    description: "Reference to another collection",
+    zodTypes: ["ZodString", "ZodArray<ZodString>"],
+    supportsMultiple: true
+  },
+  file: {
+    type: "file",
+    description: "File upload field",
+    zodTypes: ["File", "ZodArray<File>"],
+    supportsMultiple: true
+  },
+  json: {
+    type: "json",
+    description: "JSON data field",
+    zodTypes: ["ZodRecord", "ZodObject", "ZodArray"],
+    supportsMultiple: false
+  },
+  geoPoint: {
+    type: "geoPoint",
+    description: "Geographic coordinates (lon, lat)",
+    zodTypes: ["ZodObject with lon/lat"],
+    supportsMultiple: false
+  }
+};
+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;
+}
+function unwrapZodType(zodType) {
+  let unwrapped = zodType;
+  if (unwrapped instanceof z.ZodOptional) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof z.ZodNullable) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof z.ZodDefault) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  return unwrapped;
+}
+function getDefaultValue(zodType) {
+  if (zodType instanceof z.ZodDefault) {
+    return zodType._def.defaultValue();
+  }
+  return void 0;
+}
+function isArrayType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  return unwrapped instanceof z.ZodArray;
+}
+function getArrayElementType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped instanceof z.ZodArray) {
+    return unwrapped._def.type;
+  }
+  return null;
+}
+function isGeoPointType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (!(unwrapped instanceof z.ZodObject)) {
+    return false;
+  }
+  const shape = unwrapped._def.shape();
+  const hasLon = "lon" in shape && shape.lon instanceof z.ZodNumber;
+  const hasLat = "lat" in shape && shape.lat instanceof z.ZodNumber;
+  return hasLon && hasLat;
+}
+function extractComprehensiveFieldOptions(zodType) {
+  const options = {};
+  const unwrapped = unwrapZodType(zodType);
+  const checks = unwrapped._def?.checks || [];
+  if (unwrapped 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 (unwrapped 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 (unwrapped instanceof z.ZodEnum) {
+    options.values = unwrapped._def.values;
+  }
+  if (unwrapped instanceof z.ZodArray) {
+    const arrayDef = unwrapped._def;
+    if (arrayDef.minLength) {
+      options.minSelect = arrayDef.minLength.value;
+    }
+    if (arrayDef.maxLength) {
+      options.maxSelect = arrayDef.maxLength.value;
+    }
+    const elementType = arrayDef.type;
+    if (elementType instanceof z.ZodEnum) {
+      options.values = elementType._def.values;
+    }
+  }
+  return options;
+}
+function isEditorField(fieldName) {
+  const editorFieldNames = [
+    "content",
+    "body",
+    "description",
+    "bio",
+    "about",
+    "summary",
+    "notes",
+    "details",
+    "html",
+    "richtext",
+    "editor"
+  ];
+  return editorFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function isFileFieldByName(fieldName) {
+  const fileFieldNames = [
+    "avatar",
+    "image",
+    "file",
+    "attachment",
+    "photo",
+    "picture",
+    "document",
+    "upload",
+    "thumbnail",
+    "cover",
+    "banner",
+    "logo",
+    "icon",
+    "media"
+  ];
+  return fileFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function getFieldTypeInfo(zodType, fieldName) {
+  const type = mapZodTypeToPocketBase(zodType, fieldName);
+  const isMultiple = isArrayType(zodType);
+  const options = extractComprehensiveFieldOptions(zodType);
+  return {
+    type,
+    isMultiple,
+    options
+  };
+}
+
+// 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 (!fs2.existsSync(schemaDir)) {
+      throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
+    }
+    const files = fs2.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, ...excludeFields || []]);
+  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);
+}
+var SchemaAnalyzer = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig(config);
+  }
+  /**
+   * Discovers schema files in the configured directory
+   */
+  discoverSchemaFiles() {
+    return discoverSchemaFiles(this.config);
+  }
+  /**
+   * Parses all schema files and returns a SchemaDefinition
+   */
+  async parseSchemaFiles() {
+    return buildSchemaDefinition(this.config);
+  }
+  /**
+   * Converts a single Zod schema to a CollectionSchema
+   */
+  convertZodSchemaToCollectionSchema(name, schema) {
+    return convertZodSchemaToCollectionSchema(name, schema);
+  }
+};
+var SNAPSHOT_VERSION = "1.0.0";
+var DEFAULT_SNAPSHOT_FILENAME = ".migration-snapshot.json";
+var SNAPSHOT_MIGRATIONS = [
+  // Add migrations here as the format evolves
+  // Example:
+  // {
+  //   fromVersion: '0.9.0',
+  //   toVersion: '1.0.0',
+  //   migrate: (data) => ({ ...data, newField: 'default' })
+  // }
+];
+var DEFAULT_CONFIG2 = {
+  snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
+  workspaceRoot: process.cwd(),
+  autoMigrate: true,
+  version: SNAPSHOT_VERSION
+};
+function mergeConfig2(config = {}) {
+  return {
+    ...DEFAULT_CONFIG2,
+    ...config
+  };
+}
+function getSnapshotPath(config = {}) {
+  const mergedConfig = mergeConfig2(config);
+  const workspaceRoot = mergedConfig.workspaceRoot;
+  const snapshotFilename = mergedConfig.snapshotPath;
+  if (path4.isAbsolute(snapshotFilename)) {
+    return snapshotFilename;
+  }
+  return path4.join(workspaceRoot, snapshotFilename);
+}
+function snapshotExists(config = {}) {
+  try {
+    const snapshotPath = getSnapshotPath(config);
+    return fs2.existsSync(snapshotPath);
+  } catch {
+    return false;
+  }
+}
+function handleFileSystemError(error, operation, filePath) {
+  const fsError = error;
+  if (fsError.code === "ENOENT") {
+    throw new SnapshotError(`Snapshot file not found: ${filePath}`, filePath, operation, error);
+  } else if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+    throw new FileSystemError(
+      `Permission denied ${operation === "read" ? "reading" : "writing"} snapshot file. Check file permissions.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else if (fsError.code === "ENOSPC") {
+    throw new FileSystemError(
+      `No space left on device when ${operation === "read" ? "reading" : "writing"} snapshot file.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else {
+    throw new SnapshotError(`Failed to ${operation} snapshot file: ${error.message}`, filePath, operation, error);
+  }
+}
+function serializeMap(map) {
+  const obj = {};
+  for (const [key, value] of map.entries()) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function deserializeMap(obj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    map.set(key, value);
+  }
+  return map;
+}
+function serializeSchemaDefinition(schema) {
+  return {
+    collections: serializeMap(schema.collections)
+  };
+}
+function addSnapshotMetadata(schema, config) {
+  const mergedConfig = mergeConfig2(config);
+  return {
+    version: mergedConfig.version,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...serializeSchemaDefinition(schema)
+  };
+}
+function saveSnapshot(schema, config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const snapshotDir = path4.dirname(snapshotPath);
+    if (!fs2.existsSync(snapshotDir)) {
+      fs2.mkdirSync(snapshotDir, { recursive: true });
+    }
+    const snapshotData = addSnapshotMetadata(schema, config);
+    const jsonContent = JSON.stringify(snapshotData, null, 2);
+    fs2.writeFileSync(snapshotPath, jsonContent, "utf-8");
+  } catch (error) {
+    handleFileSystemError(error, "write", snapshotPath);
+  }
+}
+function parseAndValidateSnapshot(jsonContent, snapshotPath) {
+  try {
+    const data = JSON.parse(jsonContent);
+    if (!data.version) {
+      throw new SnapshotError(
+        "Snapshot file is missing version field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.timestamp) {
+      throw new SnapshotError(
+        "Snapshot file is missing timestamp field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.collections) {
+      throw new SnapshotError(
+        "Snapshot file is missing collections field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error instanceof SyntaxError) {
+      throw new SnapshotError(
+        `Invalid JSON in snapshot file. The file may be corrupted or manually edited incorrectly.`,
+        snapshotPath,
+        "parse",
+        error
+      );
+    }
+    throw error;
+  }
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+function migrateSnapshotFormat(data, config) {
+  const mergedConfig = mergeConfig2(config);
+  const currentVersion = data.version;
+  const targetVersion = mergedConfig.version;
+  if (currentVersion === targetVersion) {
+    return data;
+  }
+  if (!mergedConfig.autoMigrate) {
+    console.warn(
+      `Snapshot version ${currentVersion} differs from current ${targetVersion}, but auto-migrate is disabled.`
+    );
+    return data;
+  }
+  let migratedData = { ...data };
+  let currentMigrationVersion = currentVersion;
+  const sortedMigrations = [...SNAPSHOT_MIGRATIONS].sort((a, b) => compareVersions(a.fromVersion, b.fromVersion));
+  for (const migration of sortedMigrations) {
+    if (compareVersions(currentMigrationVersion, migration.fromVersion) === 0) {
+      console.log(`Migrating snapshot from ${migration.fromVersion} to ${migration.toVersion}...`);
+      migratedData = migration.migrate(migratedData);
+      migratedData.version = migration.toVersion;
+      currentMigrationVersion = migration.toVersion;
+    }
+  }
+  if (compareVersions(currentMigrationVersion, targetVersion) !== 0) {
+    console.warn(`Unknown snapshot version ${currentVersion}, attempting to load anyway...`);
+  }
+  return migratedData;
+}
+function deserializeSnapshot(data) {
+  return {
+    version: data.version,
+    timestamp: data.timestamp,
+    collections: deserializeMap(data.collections)
+  };
+}
+function loadSnapshot(config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const jsonContent = fs2.readFileSync(snapshotPath, "utf-8");
+    const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
+    const migratedData = migrateSnapshotFormat(data, config);
+    return deserializeSnapshot(migratedData);
+  } catch (error) {
+    if (error instanceof SnapshotError || error instanceof FileSystemError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Snapshot file not found. This may be the first migration run.`,
+        snapshotPath,
+        "read",
+        error
+      );
+    }
+    handleFileSystemError(error, "read", snapshotPath);
+  }
+}
+function mergeSnapshots(baseSnapshot, customSnapshot) {
+  if (!customSnapshot) {
+    return baseSnapshot;
+  }
+  const mergedCollections = new Map(baseSnapshot.collections);
+  for (const [name, schema] of customSnapshot.collections.entries()) {
+    mergedCollections.set(name, schema);
+  }
+  return {
+    version: customSnapshot.version || baseSnapshot.version,
+    timestamp: customSnapshot.timestamp || baseSnapshot.timestamp,
+    collections: mergedCollections
+  };
+}
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs2.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs2.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 (fs2.existsSync(migrationsPath) && fs2.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs2.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 = fs2.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
+    );
+  }
+}
+function loadBaseMigration(migrationPath) {
+  try {
+    if (!fs2.existsSync(migrationPath)) {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.
+If the file exists in a different location, update the configuration.`,
+        migrationPath,
+        "read"
+      );
+    }
+    const migrationContent = fs2.readFileSync(migrationPath, "utf-8");
+    const snapshot = convertPocketBaseMigration(migrationContent);
+    return snapshot;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.`,
+        migrationPath,
+        "read",
+        error
+      );
+    }
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied reading base migration file. Check file permissions.`,
+        migrationPath,
+        "read",
+        error.code,
+        error
+      );
+    }
+    throw new SnapshotError(
+      `Failed to load base migration: ${error instanceof Error ? error.message : String(error)}`,
+      migrationPath,
+      "read",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function getSnapshotVersion() {
+  return SNAPSHOT_VERSION;
+}
+function validateSnapshot(snapshot) {
+  const issues = [];
+  if (!snapshot.version) {
+    issues.push("Missing version field");
+  } else if (compareVersions(snapshot.version, SNAPSHOT_VERSION) > 0) {
+    issues.push(`Snapshot version ${snapshot.version} is newer than supported version ${SNAPSHOT_VERSION}`);
+  }
+  if (!snapshot.timestamp) {
+    issues.push("Missing timestamp field");
+  }
+  if (!snapshot.collections) {
+    issues.push("Missing collections field");
+  } else if (!(snapshot.collections instanceof Map)) {
+    issues.push("Collections field is not a Map");
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+var SnapshotManager = class {
+  config;
+  constructor(config = {}) {
+    this.config = mergeConfig2(config);
+  }
+  /**
+   * Loads the current snapshot
+   */
+  loadSnapshot() {
+    return loadSnapshot(this.config);
+  }
+  /**
+   * Saves a schema as a snapshot
+   */
+  saveSnapshot(schema) {
+    saveSnapshot(schema, this.config);
+  }
+  /**
+   * Loads snapshot if it exists, returns null otherwise
+   */
+  loadSnapshotIfExists() {
+    return loadSnapshotIfExists(this.config);
+  }
+  /**
+   * Checks if a snapshot exists
+   */
+  snapshotExists() {
+    return snapshotExists(this.config);
+  }
+  /**
+   * Converts a PocketBase migration to a snapshot
+   */
+  convertPocketBaseMigration(content) {
+    return convertPocketBaseMigration(content);
+  }
+  /**
+   * Gets the snapshot file path
+   */
+  getSnapshotPath() {
+    return getSnapshotPath(this.config);
+  }
+  /**
+   * Validates a snapshot
+   */
+  validateSnapshot(snapshot) {
+    return validateSnapshot(snapshot);
+  }
+};
+
+// src/migration/diff.ts
+var DEFAULT_CONFIG3 = {
+  warnOnDelete: true,
+  requireForceForDestructive: true,
+  severityThreshold: "high",
+  systemCollections: ["_mfas", "_otps", "_externalAuths", "_authOrigins", "_superusers"],
+  usersSystemFields: ["id", "password", "tokenKey", "email", "emailVisibility", "verified", "created", "updated"]
+};
+function mergeConfig3(config) {
+  return {
+    ...DEFAULT_CONFIG3,
+    ...config
+  };
+}
+function isSystemCollection(collectionName, config) {
+  const mergedConfig = mergeConfig3(config);
+  return mergedConfig.systemCollections.includes(collectionName);
+}
+function getUsersSystemFields(config) {
+  const mergedConfig = mergeConfig3(config);
+  return new Set(mergedConfig.usersSystemFields);
+}
+function filterSystemCollections(schema, config) {
+  const filteredCollections = /* @__PURE__ */ new Map();
+  for (const [collectionName, collectionSchema] of schema.collections) {
+    if (!isSystemCollection(collectionName, config)) {
+      filteredCollections.set(collectionName, collectionSchema);
+    }
+  }
+  return {
+    collections: filteredCollections
+  };
+}
+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 detectDestructiveChanges(diff, config) {
+  const destructiveChanges = [];
+  const mergedConfig = mergeConfig3(config);
+  for (const collection of diff.collectionsToDelete) {
+    destructiveChanges.push({
+      type: "collection_delete",
+      severity: "high",
+      collection: collection.name,
+      description: `Delete collection: ${collection.name}`
+    });
+  }
+  for (const modification of diff.collectionsToModify) {
+    const collectionName = modification.collection;
+    for (const field of modification.fieldsToRemove) {
+      destructiveChanges.push({
+        type: "field_delete",
+        severity: "high",
+        collection: collectionName,
+        field: field.name,
+        description: `Delete field: ${collectionName}.${field.name}`
+      });
+    }
+    for (const fieldMod of modification.fieldsToModify) {
+      const typeChange = fieldMod.changes.find((c) => c.property === "type");
+      const requiredChange = fieldMod.changes.find((c) => c.property === "required" && c.newValue === true);
+      if (typeChange) {
+        destructiveChanges.push({
+          type: "type_change",
+          severity: "high",
+          collection: collectionName,
+          field: fieldMod.fieldName,
+          description: `Change field type: ${collectionName}.${fieldMod.fieldName} (${typeChange.oldValue} \u2192 ${typeChange.newValue})`,
+          oldValue: typeChange.oldValue,
+          newValue: typeChange.newValue
+        });
+      }
+      if (requiredChange && mergedConfig.severityThreshold !== "high") {
+        destructiveChanges.push({
+          type: "required_change",
+          severity: "medium",
+          collection: collectionName,
+          field: fieldMod.fieldName,
+          description: `Make field required: ${collectionName}.${fieldMod.fieldName}`,
+          oldValue: false,
+          newValue: true
+        });
+      }
+      if (mergedConfig.severityThreshold === "low") {
+        const otherChanges = fieldMod.changes.filter((c) => c.property !== "type" && c.property !== "required");
+        for (const change of otherChanges) {
+          destructiveChanges.push({
+            type: "constraint_change",
+            severity: "low",
+            collection: collectionName,
+            field: fieldMod.fieldName,
+            description: `Change constraint: ${collectionName}.${fieldMod.fieldName}.${change.property}`,
+            oldValue: change.oldValue,
+            newValue: change.newValue
+          });
+        }
+      }
+    }
+  }
+  return destructiveChanges;
+}
+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 generateChangeSummary(diff, config) {
+  const destructiveChanges = detectDestructiveChanges(diff, config);
+  const { nonDestructive } = categorizeChangesBySeverity(diff);
+  let fieldsToAdd = 0;
+  let fieldsToRemove = 0;
+  let fieldsToModify = 0;
+  let indexChanges = 0;
+  let ruleChanges = 0;
+  let permissionChanges = 0;
+  for (const modification of diff.collectionsToModify) {
+    fieldsToAdd += modification.fieldsToAdd.length;
+    fieldsToRemove += modification.fieldsToRemove.length;
+    fieldsToModify += modification.fieldsToModify.length;
+    indexChanges += modification.indexesToAdd.length + modification.indexesToRemove.length;
+    ruleChanges += modification.rulesToUpdate.length;
+    permissionChanges += modification.permissionsToUpdate.length;
+  }
+  return {
+    totalChanges: diff.collectionsToCreate.length + diff.collectionsToDelete.length + diff.collectionsToModify.length,
+    collectionsToCreate: diff.collectionsToCreate.length,
+    collectionsToDelete: diff.collectionsToDelete.length,
+    collectionsToModify: diff.collectionsToModify.length,
+    fieldsToAdd,
+    fieldsToRemove,
+    fieldsToModify,
+    indexChanges,
+    ruleChanges,
+    permissionChanges,
+    destructiveChanges,
+    nonDestructiveChanges: nonDestructive
+  };
+}
+function requiresForceFlag(diff, config) {
+  const mergedConfig = mergeConfig3(config);
+  if (!mergedConfig.requireForceForDestructive) {
+    return false;
+  }
+  const destructiveChanges = detectDestructiveChanges(diff, config);
+  const relevantChanges = destructiveChanges.filter((change) => {
+    switch (mergedConfig.severityThreshold) {
+      case "high":
+        return change.severity === "high";
+      case "medium":
+        return change.severity === "high" || change.severity === "medium";
+      case "low":
+        return true;
+      default:
+        return change.severity === "high";
+    }
+  });
+  return relevantChanges.length > 0;
+}
+function compare(currentSchema, previousSnapshot, config) {
+  return aggregateChanges(currentSchema, previousSnapshot, config);
+}
+var DiffEngine = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig3(config);
+  }
+  /**
+   * Compares current schema with previous snapshot
+   */
+  compare(currentSchema, previousSnapshot) {
+    return compare(currentSchema, previousSnapshot, this.config);
+  }
+  /**
+   * Detects destructive changes in a diff
+   */
+  detectDestructiveChanges(diff) {
+    return detectDestructiveChanges(diff, this.config);
+  }
+  /**
+   * Categorizes changes by severity
+   */
+  categorizeChangesBySeverity(diff) {
+    return categorizeChangesBySeverity(diff, this.config);
+  }
+  /**
+   * Generates a summary of changes
+   */
+  generateChangeSummary(diff) {
+    return generateChangeSummary(diff, this.config);
+  }
+  /**
+   * Checks if force flag is required
+   */
+  requiresForceFlag(diff) {
+    return requiresForceFlag(diff, this.config);
+  }
+};
+var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
+migrate((app) => {
+{{UP_CODE}}
+  return true;
+}, (app) => {
+{{DOWN_CODE}}
+  return true;
+});
+`;
+var DEFAULT_CONFIG4 = {
+  workspaceRoot: process.cwd(),
+  timestampGenerator: () => Math.floor(Date.now() / 1e3).toString(),
+  template: DEFAULT_TEMPLATE,
+  includeTypeReference: true,
+  typesPath: "../pb_data/types.d.ts"
+};
+function mergeConfig4(config) {
+  return {
+    ...DEFAULT_CONFIG4,
+    ...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 ? mergeConfig4(config) : DEFAULT_CONFIG4;
+  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 (!fs2.existsSync(migrationDir)) {
+      try {
+        fs2.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);
+    fs2.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 MigrationGenerator = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig4(config);
+  }
+  /**
+   * Generates a migration file from a schema diff
+   */
+  generate(diff) {
+    return generate(diff, this.config);
+  }
+  /**
+   * Generates the up migration code without writing to file
+   */
+  generateUpMigration(diff) {
+    return generateUpMigration(diff);
+  }
+  /**
+   * Generates the down migration code without writing to file
+   */
+  generateDownMigration(diff) {
+    return generateDownMigration(diff);
+  }
+  /**
+   * Generates a migration filename
+   */
+  generateMigrationFilename(diff) {
+    return generateMigrationFilename(diff, this.config);
+  }
+};
+
+// 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 detectDestructiveChanges2(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 requiresForceFlag2(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 (fs2.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function loadJsonConfig(configPath) {
+  try {
+    const content = fs2.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 (!fs2.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 mergeConfig5(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) => fs2.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 (!fs2.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 (fs2.existsSync(dir)) {
+        const found = findConfigFile(dir);
+        if (found) {
+          configFilePath = found;
+          break;
+        }
+      }
+    }
+  }
+  if (configFilePath) {
+    const fileConfig = await loadConfigFile(configFilePath);
+    if (fileConfig) {
+      config = mergeConfig5(config, fileConfig);
+    }
+  }
+  const envConfig = loadConfigFromEnv();
+  if (Object.keys(envConfig).length > 0) {
+    config = mergeConfig5(config, envConfig);
+  }
+  const argsConfig = loadConfigFromArgs(options);
+  if (Object.keys(argsConfig).length > 0) {
+    config = mergeConfig5(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) => fs2.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) => fs2.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 = detectDestructiveChanges2(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 && requiresForceFlag2(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 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);
+  }
+}
+
+export { CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, ProjectInputSchema, ProjectSchema, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, UserInputSchema, UserMutator, UserSchema, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, relationField, relationsField, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map