pocketbase-zod-schema 0.1.2

package/dist/index.cjs

@@ -0,0 +1,4900 @@
+'use strict';
+
+var zod = require('zod');
+var fs2 = require('fs');
+var path4 = require('path');
+var chalk = require('chalk');
+var ora = require('ora');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+
+// src/enums.ts
+var StatusEnum = zod.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: zod.z.string().describe("unique id"),
+  collectionId: zod.z.string().describe("collection id"),
+  collectionName: zod.z.string().describe("collection name"),
+  expand: zod.z.record(zod.z.any()).describe("expandable fields")
+};
+var baseSchemaWithTimestamps = {
+  ...baseSchema,
+  created: zod.z.string().describe("creation timestamp"),
+  updated: zod.z.string().describe("last update timestamp")
+};
+var baseImageFileSchema = {
+  ...baseSchema,
+  thumbnailURL: zod.z.string().optional(),
+  imageFiles: zod.z.array(zod.z.string())
+};
+var inputImageFileSchema = {
+  imageFiles: zod.z.array(zod.z.instanceof(File))
+};
+var omitImageFilesSchema = {
+  imageFiles: true
+};
+function textField(options) {
+  let schema = zod.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 zod.z.string().email();
+}
+function urlField() {
+  return zod.z.string().url();
+}
+function numberField(options) {
+  let schema = zod.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 zod.z.boolean();
+}
+function dateField() {
+  return zod.z.date();
+}
+function selectField(values) {
+  return zod.z.enum(values);
+}
+function jsonField(schema) {
+  return schema ?? zod.z.record(zod.z.any());
+}
+function fileField() {
+  return zod.z.instanceof(File);
+}
+function filesField(options) {
+  let schema = zod.z.array(zod.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 zod.z.string();
+}
+function relationsField(options) {
+  let schema = zod.z.array(zod.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 zod.z.string();
+}
+function geoPointField() {
+  return zod.z.object({
+    lon: zod.z.number(),
+    lat: zod.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 = zod.z.object({
+  // Required fields
+  title: zod.z.string(),
+  content: zod.z.string(),
+  status: StatusEnum,
+  summary: zod.z.string().optional(),
+  User: zod.z.string().nonempty("User ID is missing"),
+  SubscriberUsers: zod.z.array(zod.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 = zod.z.object({
+  name: zod.z.string().min(2, "Name must be longer").optional(),
+  email: zod.z.string().email(),
+  password: zod.z.string().min(8, "Password must be at least 8 characters"),
+  passwordConfirm: zod.z.string(),
+  avatar: zod.z.instanceof(File).optional()
+});
+var UserDatabaseSchema = zod.z.object({
+  name: zod.z.string().min(2, "Name must be longer").optional(),
+  email: zod.z.string().email(),
+  password: zod.z.string().min(8, "Password must be at least 8 characters"),
+  avatar: zod.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 zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.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 zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.z.ZodArray)) {
+    return false;
+  }
+  const elementType = unwrappedType._def.type;
+  if (!(elementType instanceof zod.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 zod.z.ZodOptional) {
+      unwrappedType = zodType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodNullable) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodDefault) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.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 zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.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 zod.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 zod.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 zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.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 zod.z.ZodString) {
+    return mapZodStringType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodNumber) {
+    return mapZodNumberType();
+  }
+  if (unwrappedType instanceof zod.z.ZodBoolean) {
+    return mapZodBooleanType();
+  }
+  if (unwrappedType instanceof zod.z.ZodEnum) {
+    return mapZodEnumType();
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    return mapZodArrayType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodDate) {
+    return mapZodDateType();
+  }
+  if (unwrappedType instanceof zod.z.ZodRecord || unwrappedType instanceof zod.z.ZodObject) {
+    return mapZodRecordType();
+  }
+  return "text";
+}
+function extractFieldOptions(zodType) {
+  const options = {};
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  const checks = unwrappedType._def?.checks || [];
+  if (unwrappedType instanceof zod.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 zod.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 zod.z.ZodEnum) {
+    options.values = unwrappedType._def.values;
+  }
+  if (unwrappedType instanceof zod.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 zod.z.ZodOptional) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodDefault) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodNullable) {
+    return false;
+  }
+  return true;
+}
+function unwrapZodType(zodType) {
+  let unwrapped = zodType;
+  if (unwrapped instanceof zod.z.ZodOptional) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodNullable) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodDefault) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  return unwrapped;
+}
+function getDefaultValue(zodType) {
+  if (zodType instanceof zod.z.ZodDefault) {
+    return zodType._def.defaultValue();
+  }
+  return void 0;
+}
+function isArrayType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  return unwrapped instanceof zod.z.ZodArray;
+}
+function getArrayElementType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped instanceof zod.z.ZodArray) {
+    return unwrapped._def.type;
+  }
+  return null;
+}
+function isGeoPointType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (!(unwrapped instanceof zod.z.ZodObject)) {
+    return false;
+  }
+  const shape = unwrapped._def.shape();
+  const hasLon = "lon" in shape && shape.lon instanceof zod.z.ZodNumber;
+  const hasLat = "lat" in shape && shape.lat instanceof zod.z.ZodNumber;
+  return hasLon && hasLat;
+}
+function extractComprehensiveFieldOptions(zodType) {
+  const options = {};
+  const unwrapped = unwrapZodType(zodType);
+  const checks = unwrapped._def?.checks || [];
+  if (unwrapped instanceof zod.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 zod.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 zod.z.ZodEnum) {
+    options.values = unwrapped._def.values;
+  }
+  if (unwrapped instanceof zod.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 zod.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__namespace.isAbsolute(config.schemaDir)) {
+    return config.schemaDir;
+  }
+  return path4__namespace.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__namespace.existsSync(schemaDir)) {
+      throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
+    }
+    const files = fs2__namespace.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__namespace.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__namespace.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__namespace.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 zod.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__namespace.isAbsolute(snapshotFilename)) {
+    return snapshotFilename;
+  }
+  return path4__namespace.join(workspaceRoot, snapshotFilename);
+}
+function snapshotExists(config = {}) {
+  try {
+    const snapshotPath = getSnapshotPath(config);
+    return fs2__namespace.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__namespace.dirname(snapshotPath);
+    if (!fs2__namespace.existsSync(snapshotDir)) {
+      fs2__namespace.mkdirSync(snapshotDir, { recursive: true });
+    }
+    const snapshotData = addSnapshotMetadata(schema, config);
+    const jsonContent = JSON.stringify(snapshotData, null, 2);
+    fs2__namespace.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__namespace.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__namespace.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs2__namespace.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__namespace.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__namespace.existsSync(migrationsPath) && fs2__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs2__namespace.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__namespace.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__namespace.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__namespace.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__namespace.isAbsolute(config.migrationDir)) {
+    return config.migrationDir;
+  }
+  return path4__namespace.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__namespace.existsSync(migrationDir)) {
+      try {
+        fs2__namespace.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__namespace.join(migrationDir, filename);
+    fs2__namespace.writeFileSync(filePath, content, "utf-8");
+    return filePath;
+  } catch (error) {
+    if (error instanceof FileSystemError) {
+      throw error;
+    }
+    const fsError = error;
+    const filePath = path4__namespace.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__namespace.join(directory, fileName);
+    if (fs2__namespace.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function loadJsonConfig(configPath) {
+  try {
+    const content = fs2__namespace.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__namespace.existsSync(configPath)) {
+    return null;
+  }
+  const ext = path4__namespace.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__namespace.resolve(cwd, config.schema.directory),
+    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+  ];
+  const schemaDir = possiblePaths.find((p) => fs2__namespace.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__namespace.resolve(cwd, options.config);
+    if (!fs2__namespace.existsSync(explicitPath)) {
+      throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
+    }
+    configFilePath = explicitPath;
+  } else {
+    const searchDirs = [cwd, path4__namespace.join(cwd, "shared")];
+    for (const dir of searchDirs) {
+      if (fs2__namespace.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__namespace.resolve(cwd, config.schema.directory),
+    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+  ];
+  return possiblePaths.find((p) => fs2__namespace.existsSync(p)) || possiblePaths[0];
+}
+function getMigrationsDirectory(config) {
+  const cwd = process.cwd();
+  const possiblePaths = [
+    path4__namespace.resolve(cwd, config.migrations.directory),
+    path4__namespace.resolve(cwd, "shared", config.migrations.directory)
+  ];
+  return possiblePaths.find((p) => fs2__namespace.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__default.default({ text, isSilent: true });
+  }
+  return ora__default.default(text);
+}
+function logSuccess(message) {
+  if (shouldLog("normal")) {
+    console.log(chalk__default.default.green("\u2713"), message);
+  }
+}
+function logError(message) {
+  console.error(chalk__default.default.red("\u2717"), message);
+}
+function logWarning(message) {
+  if (shouldLog("normal")) {
+    console.warn(chalk__default.default.yellow("\u26A0"), message);
+  }
+}
+function logInfo(message) {
+  if (shouldLog("normal")) {
+    console.log(chalk__default.default.blue("\u2139"), message);
+  }
+}
+function logDebug(message) {
+  if (shouldLog("verbose")) {
+    console.log(chalk__default.default.gray("\u2699"), chalk__default.default.gray(message));
+  }
+}
+function logSection(title) {
+  if (shouldLog("normal")) {
+    console.log();
+    console.log(chalk__default.default.bold.cyan(title));
+    console.log(chalk__default.default.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__default.default.red(oldValue)} \u2192 ${chalk__default.default.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__default.default.gray("No changes detected");
+  }
+  lines.push(chalk__default.default.bold(`Found ${totalChanges} collection change(s):`));
+  lines.push("");
+  if (totalCollectionsToCreate > 0) {
+    lines.push(chalk__default.default.green.bold(`\u2713 ${totalCollectionsToCreate} collection(s) to create:`));
+    for (const collection of diff.collectionsToCreate) {
+      lines.push(chalk__default.default.green(`  + ${collection.name} (${collection.type})`));
+      lines.push(chalk__default.default.gray(`    ${collection.fields.length} field(s)`));
+    }
+    lines.push("");
+  }
+  if (totalCollectionsToDelete > 0) {
+    lines.push(chalk__default.default.red.bold(`\u2717 ${totalCollectionsToDelete} collection(s) to delete:`));
+    for (const collection of diff.collectionsToDelete) {
+      lines.push(chalk__default.default.red(`  - ${collection.name}`));
+    }
+    lines.push("");
+  }
+  if (totalCollectionsToModify > 0) {
+    lines.push(chalk__default.default.yellow.bold(`\u26A1 ${totalCollectionsToModify} collection(s) to modify:`));
+    for (const modification of diff.collectionsToModify) {
+      lines.push(chalk__default.default.yellow(`  ~ ${modification.collection}`));
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(chalk__default.default.green(`    + ${modification.fieldsToAdd.length} field(s) to add:`));
+        for (const field of modification.fieldsToAdd) {
+          lines.push(chalk__default.default.green(`      + ${field.name} (${field.type})`));
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(chalk__default.default.red(`    - ${modification.fieldsToRemove.length} field(s) to remove:`));
+        for (const field of modification.fieldsToRemove) {
+          lines.push(chalk__default.default.red(`      - ${field.name}`));
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(chalk__default.default.yellow(`    ~ ${modification.fieldsToModify.length} field(s) to modify:`));
+        for (const fieldMod of modification.fieldsToModify) {
+          lines.push(chalk__default.default.yellow(`      ~ ${fieldMod.fieldName}`));
+          for (const change of fieldMod.changes) {
+            lines.push(chalk__default.default.gray(`        ${formatFieldChange(change)}`));
+          }
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(chalk__default.default.green(`    + ${modification.indexesToAdd.length} index(es) to add`));
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(chalk__default.default.red(`    - ${modification.indexesToRemove.length} index(es) to remove`));
+      }
+      if (modification.rulesToUpdate.length > 0) {
+        lines.push(chalk__default.default.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__default.default.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__default.default.bold(headerLine));
+  console.log(chalk__default.default.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__namespace.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__default.default.red(`  ${change}`));
+    }
+    console.log();
+  }
+  if (nonDestructive.length > 0) {
+    logSection("\u2713 Non-Destructive Changes");
+    console.log();
+    for (const change of nonDestructive) {
+      console.log(chalk__default.default.green(`  ${change}`));
+    }
+    console.log();
+  }
+}
+function displayChangeTable(diff) {
+  const rows = [];
+  for (const collection of diff.collectionsToCreate) {
+    rows.push([
+      chalk__default.default.green("+"),
+      collection.name,
+      collection.type,
+      `${collection.fields.length} fields`,
+      chalk__default.default.green("Create")
+    ]);
+  }
+  for (const collection of diff.collectionsToDelete) {
+    rows.push([chalk__default.default.red("-"), collection.name, collection.type || "base", "-", chalk__default.default.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__default.default.yellow("~"), mod.collection, "-", changes.join(", ") || "No changes", chalk__default.default.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__default.default.cyan("     pocketbase-migrate generate"));
+    console.log();
+    const { destructive } = categorizeChangesBySeverity(diff);
+    if (destructive.length > 0) {
+      console.log(chalk__default.default.yellow("  \u26A0\uFE0F  Destructive changes detected. Use --force flag when generating:"));
+      console.log(chalk__default.default.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);
+  }
+}
+
+exports.CLIUsageError = CLIUsageError;
+exports.ConfigurationError = ConfigurationError;
+exports.DiffEngine = DiffEngine;
+exports.FIELD_TYPE_INFO = FIELD_TYPE_INFO;
+exports.FileSystemError = FileSystemError;
+exports.MigrationError = MigrationError;
+exports.MigrationGenerationError = MigrationGenerationError;
+exports.MigrationGenerator = MigrationGenerator;
+exports.POCKETBASE_FIELD_TYPES = POCKETBASE_FIELD_TYPES;
+exports.PermissionTemplates = PermissionTemplates;
+exports.ProjectInputSchema = ProjectInputSchema;
+exports.ProjectSchema = ProjectSchema;
+exports.SchemaAnalyzer = SchemaAnalyzer;
+exports.SchemaParsingError = SchemaParsingError;
+exports.SnapshotError = SnapshotError;
+exports.SnapshotManager = SnapshotManager;
+exports.StatusEnum = StatusEnum;
+exports.UserInputSchema = UserInputSchema;
+exports.UserMutator = UserMutator;
+exports.UserSchema = UserSchema;
+exports.aggregateChanges = aggregateChanges;
+exports.baseImageFileSchema = baseImageFileSchema;
+exports.baseSchema = baseSchema;
+exports.baseSchemaWithTimestamps = baseSchemaWithTimestamps;
+exports.boolField = boolField;
+exports.buildFieldDefinition = buildFieldDefinition;
+exports.buildSchemaDefinition = buildSchemaDefinition;
+exports.categorizeChangesBySeverity = categorizeChangesBySeverity;
+exports.compare = compare;
+exports.compareFieldConstraints = compareFieldConstraints;
+exports.compareFieldOptions = compareFieldOptions;
+exports.compareFieldTypes = compareFieldTypes;
+exports.comparePermissions = comparePermissions;
+exports.compareRelationConfigurations = compareRelationConfigurations;
+exports.convertPocketBaseMigration = convertPocketBaseMigration;
+exports.convertZodSchemaToCollectionSchema = convertZodSchemaToCollectionSchema;
+exports.createMigrationFileStructure = createMigrationFileStructure;
+exports.createPermissions = createPermissions;
+exports.dateField = dateField;
+exports.detectDestructiveChanges = detectDestructiveChanges;
+exports.detectFieldChanges = detectFieldChanges;
+exports.discoverSchemaFiles = discoverSchemaFiles;
+exports.editorField = editorField;
+exports.emailField = emailField;
+exports.extractComprehensiveFieldOptions = extractComprehensiveFieldOptions;
+exports.extractFieldDefinitions = extractFieldDefinitions;
+exports.extractFieldOptions = extractFieldOptions;
+exports.extractIndexes = extractIndexes;
+exports.extractSchemaDefinitions = extractSchemaDefinitions;
+exports.fileField = fileField;
+exports.filesField = filesField;
+exports.filterSystemCollections = filterSystemCollections;
+exports.findLatestSnapshot = findLatestSnapshot;
+exports.findNewCollections = findNewCollections;
+exports.findNewFields = findNewFields;
+exports.findRemovedCollections = findRemovedCollections;
+exports.findRemovedFields = findRemovedFields;
+exports.formatChangeSummary = formatChangeSummary;
+exports.generate = generate;
+exports.generateChangeSummary = generateChangeSummary;
+exports.generateCollectionCreation = generateCollectionCreation;
+exports.generateCollectionPermissions = generateCollectionPermissions;
+exports.generateCollectionRules = generateCollectionRules;
+exports.generateDownMigration = generateDownMigration;
+exports.generateFieldAddition = generateFieldAddition;
+exports.generateFieldDefinitionObject = generateFieldDefinitionObject;
+exports.generateFieldDeletion = generateFieldDeletion;
+exports.generateFieldModification = generateFieldModification;
+exports.generateFieldsArray = generateFieldsArray;
+exports.generateIndexesArray = generateIndexesArray;
+exports.generateMigration = executeGenerate;
+exports.generateMigrationDescription = generateMigrationDescription;
+exports.generateMigrationFilename = generateMigrationFilename;
+exports.generatePermissionUpdate = generatePermissionUpdate;
+exports.generateTimestamp = generateTimestamp;
+exports.generateUpMigration = generateUpMigration;
+exports.geoPointField = geoPointField;
+exports.getArrayElementType = getArrayElementType;
+exports.getCollectionNameFromFile = getCollectionNameFromFile;
+exports.getDefaultValue = getDefaultValue;
+exports.getFieldTypeInfo = getFieldTypeInfo;
+exports.getMaxSelect = getMaxSelect;
+exports.getMigrationStatus = executeStatus;
+exports.getMinSelect = getMinSelect;
+exports.getSnapshotPath = getSnapshotPath;
+exports.getSnapshotVersion = getSnapshotVersion;
+exports.getUsersSystemFields = getUsersSystemFields;
+exports.importSchemaModule = importSchemaModule;
+exports.inputImageFileSchema = inputImageFileSchema;
+exports.isArrayType = isArrayType;
+exports.isAuthCollection = isAuthCollection;
+exports.isEditorField = isEditorField;
+exports.isFieldRequired = isFieldRequired;
+exports.isFileFieldByName = isFileFieldByName;
+exports.isGeoPointType = isGeoPointType;
+exports.isMultipleRelationField = isMultipleRelationField;
+exports.isPermissionSchema = isPermissionSchema;
+exports.isRelationField = isRelationField;
+exports.isSingleRelationField = isSingleRelationField;
+exports.isSystemCollection = isSystemCollection;
+exports.isTemplateConfig = isTemplateConfig;
+exports.jsonField = jsonField;
+exports.loadBaseMigration = loadBaseMigration;
+exports.loadConfig = loadConfig;
+exports.loadSnapshot = loadSnapshot;
+exports.loadSnapshotIfExists = loadSnapshotIfExists;
+exports.logError = logError;
+exports.logInfo = logInfo;
+exports.logSection = logSection;
+exports.logSuccess = logSuccess;
+exports.logWarning = logWarning;
+exports.mapZodArrayType = mapZodArrayType;
+exports.mapZodBooleanType = mapZodBooleanType;
+exports.mapZodDateType = mapZodDateType;
+exports.mapZodEnumType = mapZodEnumType;
+exports.mapZodNumberType = mapZodNumberType;
+exports.mapZodRecordType = mapZodRecordType;
+exports.mapZodStringType = mapZodStringType;
+exports.mapZodTypeToPocketBase = mapZodTypeToPocketBase;
+exports.matchCollectionsByName = matchCollectionsByName;
+exports.matchFieldsByName = matchFieldsByName;
+exports.mergePermissions = mergePermissions;
+exports.mergeSnapshots = mergeSnapshots;
+exports.numberField = numberField;
+exports.omitImageFilesSchema = omitImageFilesSchema;
+exports.parseSchemaFiles = parseSchemaFiles;
+exports.pluralize = pluralize;
+exports.relationField = relationField;
+exports.relationsField = relationsField;
+exports.requiresForceFlag = requiresForceFlag;
+exports.resolveTargetCollection = resolveTargetCollection;
+exports.resolveTemplate = resolveTemplate;
+exports.saveSnapshot = saveSnapshot;
+exports.selectField = selectField;
+exports.selectSchemaForCollection = selectSchemaForCollection;
+exports.singularize = singularize;
+exports.snapshotExists = snapshotExists;
+exports.textField = textField;
+exports.toCollectionName = toCollectionName;
+exports.unwrapZodType = unwrapZodType;
+exports.urlField = urlField;
+exports.validatePermissionConfig = validatePermissionConfig;
+exports.validateRuleExpression = validateRuleExpression;
+exports.validateSnapshot = validateSnapshot;
+exports.withIndexes = withIndexes;
+exports.withPermissions = withPermissions;
+exports.withProgress = withProgress;
+exports.writeMigrationFile = writeMigrationFile;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map