pocketbase-zod-schema 1.0.0 → 1.0.2

package/dist/cli/migrate.cjs

@@ -4,7 +4,7 @@
 var chalk = require('chalk');
 var commander = require('commander');
 var fs10 = require('fs');
-var path8 = require('path');
+var path7 = require('path');
 var url = require('url');
 var zod = require('zod');
 var crypto = require('crypto');
@@ -34,7 +34,7 @@ function _interopNamespace(e) {
 
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var fs10__namespace = /*#__PURE__*/_interopNamespace(fs10);
-var path8__namespace = /*#__PURE__*/_interopNamespace(path8);
+var path7__namespace = /*#__PURE__*/_interopNamespace(path7);
 var vm__namespace = /*#__PURE__*/_interopNamespace(vm);
 var acorn__namespace = /*#__PURE__*/_interopNamespace(acorn);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
@@ -172,10 +172,10 @@ var FileSystemError = class _FileSystemError extends MigrationError {
   operation;
   code;
   originalError;
-  constructor(message, path12, operation, code, originalError) {
+  constructor(message, path11, operation, code, originalError) {
     super(message);
     this.name = "FileSystemError";
-    this.path = path12;
+    this.path = path11;
     this.operation = operation;
     this.code = code;
     this.originalError = originalError;
@@ -250,7 +250,6 @@ var DEFAULT_CONFIG = {
     "permission-templates.js"
   ],
   includeExtensions: [".ts", ".js"],
-  schemaPatterns: ["Schema", "InputSchema", "Collection"],
   useCompiledFiles: true
 };
 function mergeConfig(config) {
@@ -258,16 +257,15 @@ function mergeConfig(config) {
     ...DEFAULT_CONFIG,
     ...config,
     excludePatterns: config.excludePatterns || DEFAULT_CONFIG.excludePatterns,
-    includeExtensions: config.includeExtensions || DEFAULT_CONFIG.includeExtensions,
-    schemaPatterns: config.schemaPatterns || DEFAULT_CONFIG.schemaPatterns
+    includeExtensions: config.includeExtensions || DEFAULT_CONFIG.includeExtensions
   };
 }
 function resolveSchemaDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path8__namespace.isAbsolute(config.schemaDir)) {
+  if (path7__namespace.isAbsolute(config.schemaDir)) {
     return config.schemaDir;
   }
-  return path8__namespace.join(workspaceRoot, config.schemaDir);
+  return path7__namespace.join(workspaceRoot, config.schemaDir);
 }
 ({
   id: zod.z.string().describe("unique id"),
@@ -277,17 +275,6 @@ function resolveSchemaDir(config) {
   created: zod.z.string().describe("creation timestamp"),
   updated: zod.z.string().describe("last update timestamp")
 });
-({
-  created: zod.z.string().describe("creation timestamp"),
-  updated: zod.z.string().describe("last update timestamp")
-});
-({
-  thumbnailURL: zod.z.string().optional(),
-  imageFiles: zod.z.array(zod.z.string())
-});
-({
-  imageFiles: zod.z.array(zod.z.instanceof(File))
-});
 var RELATION_METADATA_KEY = "__pocketbase_relation__";
 function extractRelationMetadata(description) {
   if (!description) return null;
@@ -501,14 +488,15 @@ var CollectionIdRegistry = class {
 };
 
 // src/migration/rule-validator.ts
+var BACK_RELATION_SEGMENT = /^[a-zA-Z_][a-zA-Z0-9_]*_via_[a-zA-Z_][a-zA-Z0-9_]*$/;
 var RuleValidator = class {
   fields;
   collectionName;
   isAuthCollection;
-  constructor(collectionName, fields, isAuthCollection2 = false) {
+  constructor(collectionName, fields, isAuthCollection = false) {
     this.collectionName = collectionName;
     this.fields = new Map(fields.map((f) => [f.name, f]));
-    this.isAuthCollection = isAuthCollection2;
+    this.isAuthCollection = isAuthCollection;
     this.addSystemFields();
   }
   /**
@@ -576,7 +564,7 @@ var RuleValidator = class {
   /**
    * Extract field references from expression
    *
-   * Matches field names that are not @request references.
+   * Matches field names that are not @request or @collection references.
    * Handles dot notation for relations: user.email, post.author.name
    *
    * @param expression - The rule expression
@@ -586,6 +574,7 @@ var RuleValidator = class {
     const refs = [];
     let cleaned = expression2.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''");
     cleaned = cleaned.replace(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g, "");
+    cleaned = cleaned.replace(/@collection\.[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) {
@@ -606,12 +595,26 @@ var RuleValidator = class {
     const keywords = ["true", "false", "null", "AND", "OR", "NOT", "LIKE", "IN"];
     return keywords.includes(word.toUpperCase());
   }
+  /**
+   * Check whether a path segment is a back-relation rather than a field
+   *
+   * A declared field wins: a collection may legitimately contain a field
+   * literally named `foo_via_bar`, and it should be validated as one.
+   *
+   * @param segment - A single dot-separated path segment
+   * @returns True if the segment should be treated as a back-relation
+   */
+  isBackRelationSegment(segment) {
+    return !this.fields.has(segment) && BACK_RELATION_SEGMENT.test(segment);
+  }
   /**
    * 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.
+   * Only the root of the path is checked — the validator holds a single
+   * collection's fields, so anything past the first hop belongs to another
+   * collection and is accepted as-is. A root back-relation
+   * (`Members_via_WorkspaceRef.UserRef`) has no local field to check against
+   * either, so it is accepted too; PocketBase resolves it at runtime.
    *
    * @param fieldRef - The field reference to validate (e.g., "user" or "user.email")
    * @param result - The validation result to update
@@ -619,6 +622,9 @@ var RuleValidator = class {
   validateFieldReference(fieldRef, result) {
     const parts = fieldRef.split(".");
     const rootField = parts[0];
+    if (this.isBackRelationSegment(rootField)) {
+      return;
+    }
     if (!this.fields.has(rootField)) {
       result.errors.push(`Field '${rootField}' does not exist in collection '${this.collectionName}'`);
       result.valid = false;
@@ -629,10 +635,6 @@ var RuleValidator = class {
       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(".")}'`
-        );
       }
     }
   }
@@ -790,11 +792,11 @@ var PermissionAnalyzer = class {
    * }
    * ```
    */
-  validatePermissions(collectionName, permissions, fields, isAuthCollection2 = false) {
-    const validator = new RuleValidator(collectionName, fields, isAuthCollection2);
+  validatePermissions(collectionName, permissions, fields, isAuthCollection = false) {
+    const validator = new RuleValidator(collectionName, fields, isAuthCollection);
     const results = /* @__PURE__ */ new Map();
     const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
-    if (isAuthCollection2) {
+    if (isAuthCollection) {
       ruleTypes.push("manageRule");
     }
     for (const ruleType of ruleTypes) {
@@ -847,146 +849,22 @@ var PermissionAnalyzer = class {
     };
   }
 };
-
-// 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);
-}
-
-// src/migration/utils/relation-detector.ts
-function unwrapType(zodType) {
-  let unwrappedType = zodType;
-  if (unwrappedType instanceof zod.z.ZodOptional) {
-    unwrappedType = unwrappedType.unwrap();
-  }
-  if (unwrappedType instanceof zod.z.ZodNullable) {
-    unwrappedType = unwrappedType.unwrap();
-  }
-  if (unwrappedType instanceof zod.z.ZodDefault) {
-    unwrappedType = unwrappedType.unwrap();
-  }
-  return unwrappedType;
-}
+var POCKETBASE_FIELD_TYPES = [
+  "text",
+  "email",
+  "url",
+  "number",
+  "bool",
+  "date",
+  "select",
+  "relation",
+  "file",
+  "json",
+  "editor",
+  "geoPoint",
+  "autodate",
+  "password"
+];
 function getChecks(zodType) {
   const def = zodType.def ?? zodType._def;
   return def?.checks ?? [];
@@ -999,94 +877,8 @@ function getJsonSchema(zodType) {
     return null;
   }
 }
-function isSingleRelationField(fieldName, zodType) {
-  const unwrappedType = unwrapType(zodType);
-  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) {
-  const unwrappedType = unwrapType(zodType);
-  if (!(unwrappedType instanceof zod.z.ZodArray)) {
-    return false;
-  }
-  const elementType = unwrappedType.element;
-  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)) {
-    const unwrappedType = unwrapType(zodType);
-    if (unwrappedType instanceof zod.z.ZodArray) {
-      const checks = getChecks(unwrappedType);
-      const maxCheck = checks.find((check) => check.kind === "max");
-      if (maxCheck) {
-        return maxCheck.value;
-      }
-      const schema = getJsonSchema(unwrappedType);
-      if (schema && typeof schema.maxItems === "number") {
-        return schema.maxItems;
-      }
-      return 999;
-    }
-  }
-  return 1;
-}
-function getMinSelect(fieldName, zodType) {
-  if (isSingleRelationField(fieldName, zodType)) {
-    return 0;
-  }
-  if (isMultipleRelationField(fieldName, zodType)) {
-    const unwrappedType = unwrapType(zodType);
-    if (unwrappedType instanceof zod.z.ZodArray) {
-      const checks = getChecks(unwrappedType);
-      const minCheck = checks.find((check) => check.kind === "min");
-      if (minCheck) {
-        return minCheck.value;
-      }
-      const schema = getJsonSchema(unwrappedType);
-      if (schema && typeof schema.minItems === "number") {
-        return schema.minItems;
-      }
-    }
-  }
-  return 0;
-}
-function getChecks2(zodType) {
-  const def = zodType.def ?? zodType._def;
-  return def?.checks ?? [];
-}
-function getJsonSchema2(zodType) {
-  try {
-    const toJSONSchema = zodType.toJSONSchema;
-    return typeof toJSONSchema === "function" ? toJSONSchema.call(zodType) : null;
-  } catch {
-    return null;
-  }
-}
 function mapZodStringType(zodType) {
-  const checks = getChecks2(zodType);
+  const checks = getChecks(zodType);
   const hasEmail = checks.some((check) => check.kind === "email" || check.def?.format === "email");
   if (hasEmail) {
     return "email";
@@ -1112,14 +904,11 @@ function mapZodBooleanType(_zodType) {
 function mapZodEnumType(_zodType) {
   return "select";
 }
-function mapZodArrayType(zodType, _fieldName) {
+function mapZodArrayType(zodType) {
   const elementType = zodType.element;
   if (elementType instanceof zod.z.ZodFile) {
     return "file";
   }
-  if (elementType instanceof zod.z.ZodString) {
-    return "relation";
-  }
   return "json";
 }
 function mapZodDateType(_zodType) {
@@ -1128,7 +917,7 @@ function mapZodDateType(_zodType) {
 function mapZodRecordType(_zodType) {
   return "json";
 }
-function mapZodTypeToPocketBase(zodType, fieldName) {
+function mapZodTypeToPocketBase(zodType) {
   const unwrappedType = unwrapZodType(zodType);
   const metadata = extractFieldMetadata(unwrappedType.description);
   if (metadata && metadata.type) {
@@ -1158,7 +947,7 @@ function mapZodTypeToPocketBase(zodType, fieldName) {
 function extractFieldOptions(zodType) {
   const options = {};
   const unwrappedType = unwrapZodType(zodType);
-  const checks = getChecks2(unwrappedType);
+  const checks = getChecks(unwrappedType);
   if (unwrappedType instanceof zod.z.ZodString) {
     for (const check of checks) {
       if (check.kind === "min") {
@@ -1172,7 +961,7 @@ function extractFieldOptions(zodType) {
       }
     }
     if (options.min === void 0 || options.max === void 0 || options.pattern === void 0) {
-      const schema = getJsonSchema2(unwrappedType);
+      const schema = getJsonSchema(unwrappedType);
       if (schema) {
         if (options.min === void 0 && typeof schema.minLength === "number") {
           options.min = schema.minLength;
@@ -1195,7 +984,7 @@ function extractFieldOptions(zodType) {
         options.max = check.value;
       }
     }
-    const schema = getJsonSchema2(unwrappedType);
+    const schema = getJsonSchema(unwrappedType);
     if (schema) {
       if (options.min === void 0 && typeof schema.minimum === "number") {
         options.min = schema.minimum;
@@ -1213,7 +1002,7 @@ function extractFieldOptions(zodType) {
     options.values = unwrappedType.options.map(String);
   }
   if (unwrappedType instanceof zod.z.ZodArray) {
-    const arrayChecks = getChecks2(unwrappedType);
+    const arrayChecks = getChecks(unwrappedType);
     for (const check of arrayChecks) {
       if (check.kind === "min") {
         options.minSelect = check.value;
@@ -1223,7 +1012,7 @@ function extractFieldOptions(zodType) {
       }
     }
     if (options.minSelect === void 0 || options.maxSelect === void 0) {
-      const schema = getJsonSchema2(unwrappedType);
+      const schema = getJsonSchema(unwrappedType);
       if (schema) {
         if (options.minSelect === void 0 && typeof schema.minItems === "number") {
           options.minSelect = schema.minItems;
@@ -1301,6 +1090,39 @@ function filterSupportedFieldOptions(fieldType, options) {
   }
   return Object.keys(filtered).length > 0 ? filtered : void 0;
 }
+var OPTION_UNSET_VALUES = {
+  pattern: "",
+  autogeneratePattern: "",
+  cost: 0,
+  maxSize: 0,
+  maxSelect: 0,
+  minSelect: 0,
+  primaryKey: false,
+  onlyInt: false,
+  noDecimal: false,
+  convertURLs: false,
+  protected: false,
+  hidden: false,
+  presentable: false,
+  system: false,
+  values: [],
+  mimeTypes: [],
+  thumbs: [],
+  exceptDomains: [],
+  onlyDomains: []
+};
+function getFieldOptionUnsetValue(fieldType, key) {
+  if (key === "min" || key === "max") {
+    if (fieldType === "number") {
+      return null;
+    }
+    if (fieldType === "date") {
+      return "";
+    }
+    return 0;
+  }
+  return OPTION_UNSET_VALUES[key];
+}
 function dedentSql(value) {
   const lines = value.replace(/\r\n/g, "\n").split("\n");
   while (lines.length > 0 && lines[0].trim() === "") {
@@ -1355,10 +1177,6 @@ function validateViewQuery(collectionName, viewQuery) {
     );
   }
 }
-function getCollectionNameFromFile(filePath) {
-  const filename = path8__namespace.basename(filePath).replace(/\.(ts|js)$/, "");
-  return toCollectionName(filename);
-}
 function extractCollectionNameFromSchema(zodSchema) {
   if (!zodSchema.description) {
     return null;
@@ -1398,42 +1216,42 @@ function extractViewQueryFromSchema(zodSchema) {
   }
   return null;
 }
-function extractSchemaDefinitions(module, patterns = ["Schema", "InputSchema", "Collection"]) {
-  const result = {};
-  if (module.default instanceof zod.z.ZodObject) {
-    result.schema = module.default;
-  }
+function selectCollectionSchema(module) {
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const consider = (exportName, value) => {
+    if (!(value instanceof zod.z.ZodObject) || seen.has(value)) {
+      return;
+    }
+    const collectionName = extractCollectionNameFromSchema(value);
+    if (!collectionName) {
+      return;
+    }
+    seen.add(value);
+    candidates.push({ schema: value, exportName, collectionName });
+  };
+  consider("default", module.default);
   for (const [key, value] of Object.entries(module)) {
-    if (key === "default") continue;
-    if (value instanceof zod.z.ZodObject) {
-      if (patterns.includes("InputSchema") && key.endsWith("InputSchema")) {
-        result.inputSchema = value;
-      } else if (!result.schema) {
-        if (patterns.includes("Collection") && key.endsWith("Collection")) {
-          result.schema = value;
-        } else if (patterns.includes("Schema") && key.endsWith("Schema") && !key.endsWith("InputSchema")) {
-          result.schema = value;
-        }
-      }
+    if (key !== "default") {
+      consider(key, value);
     }
   }
-  return result;
-}
-function selectSchemaForCollection(schemas) {
-  if (schemas.schema) {
-    return schemas.schema;
+  if (candidates.length === 0) {
+    return null;
   }
-  if (schemas.inputSchema) {
-    return schemas.inputSchema;
+  if (candidates.length > 1) {
+    const names = candidates.map((c) => `${c.exportName} (${c.collectionName})`).join(", ");
+    throw new Error(
+      `Multiple collection schemas exported from one file: ${names}. Define one collection per file.`
+    );
   }
-  return null;
+  return candidates[0];
 }
 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, ...[]]);
+  const allExclusions = /* @__PURE__ */ new Set([...baseFields, ...[]]);
   for (const [fieldName, zodType] of Object.entries(shape)) {
     if (!allExclusions.has(fieldName)) {
       fields.push({ name: fieldName, zodType });
@@ -1646,16 +1464,15 @@ function generateFindCollectionCode(name, collectionIdMap) {
 }
 
 // src/migration/analyzer/converter.ts
-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 unwrappedType = unwrapZodType(zodType);
   const fieldMetadata = extractFieldMetadata(unwrappedType.description ?? zodType.description);
   if (fieldMetadata) {
+    if (!fieldMetadata.type || !POCKETBASE_FIELD_TYPES.includes(fieldMetadata.type)) {
+      throw new Error(
+        `Field "${fieldName}" carries __pocketbase_field__ metadata with unknown type "${fieldMetadata.type}". Use one of: ${POCKETBASE_FIELD_TYPES.join(", ")}.`
+      );
+    }
     let required2;
     if (fieldMetadata.type === "number") {
       if (fieldMetadata.options?.required !== void 0) {
@@ -1666,7 +1483,8 @@ function buildFieldDefinition(fieldName, zodType) {
     } else {
       required2 = isFieldRequired(zodType);
     }
-    const { required: _required, ...options2 } = fieldMetadata.options || {};
+    const { required: _required, ...metadataOptions } = fieldMetadata.options || {};
+    const options2 = { ...extractChainedFieldOptions(fieldMetadata.type, unwrappedType), ...metadataOptions };
     const fieldDef2 = {
       name: fieldName,
       id: generateFieldId(fieldMetadata.type, fieldName),
@@ -1689,6 +1507,26 @@ function buildFieldDefinition(fieldName, zodType) {
     }
     return fieldDef2;
   }
+  const relationMetadata = extractRelationMetadata(unwrappedType.description ?? zodType.description);
+  if (relationMetadata) {
+    return {
+      name: fieldName,
+      id: generateFieldId("relation", fieldName),
+      type: "relation",
+      required: isFieldRequired(zodType),
+      // Zod validators on the field (array min/max etc.) are already captured
+      // in the relation metadata; the field itself carries no options
+      options: void 0,
+      zodType,
+      relation: {
+        collection: relationMetadata.collection,
+        maxSelect: relationMetadata.maxSelect,
+        minSelect: relationMetadata.minSelect,
+        cascadeDelete: relationMetadata.cascadeDelete,
+        displayFields: relationMetadata.displayFields
+      }
+    };
+  }
   const fieldType = mapZodTypeToPocketBase(zodType);
   const required = isFieldRequired(zodType);
   const options = extractFieldOptions(zodType);
@@ -1700,35 +1538,6 @@ function buildFieldDefinition(fieldName, zodType) {
     options,
     zodType
   };
-  const relationMetadata = extractRelationMetadata(unwrappedType.description ?? zodType.description);
-  if (relationMetadata) {
-    fieldDef.type = "relation";
-    fieldDef.relation = {
-      collection: relationMetadata.collection,
-      maxSelect: relationMetadata.maxSelect,
-      minSelect: relationMetadata.minSelect,
-      cascadeDelete: relationMetadata.cascadeDelete,
-      displayFields: relationMetadata.displayFields
-    };
-    fieldDef.options = void 0;
-  } else 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
-      displayFields: null
-    };
-    if (fieldDef.options) {
-      const { min: _min, max: _max, pattern: _pattern, ...relationSafeOptions } = fieldDef.options;
-      fieldDef.options = Object.keys(relationSafeOptions).length ? relationSafeOptions : void 0;
-    }
-  }
   if (fieldDef.type === "autodate") {
     fieldDef.options = {
       onCreate: true,
@@ -1742,10 +1551,17 @@ function buildFieldDefinition(fieldName, zodType) {
   fieldDef.options = filterSupportedFieldOptions(fieldDef.type, fieldDef.options);
   return fieldDef;
 }
+var TYPES_READING_CHAINED_VALIDATORS = /* @__PURE__ */ new Set(["text", "password", "number", "select", "file"]);
+function extractChainedFieldOptions(fieldType, unwrappedType) {
+  if (!TYPES_READING_CHAINED_VALIDATORS.has(fieldType)) {
+    return {};
+  }
+  return extractFieldOptions(unwrappedType);
+}
 function convertZodSchemaToCollectionSchema(collectionName, zodSchema) {
   const rawFields = extractFieldDefinitions(zodSchema);
   const explicitType = extractCollectionTypeFromSchema(zodSchema);
-  const collectionType = explicitType ?? (isAuthCollection(rawFields) ? "auth" : "base");
+  const collectionType = explicitType ?? "base";
   const isView = collectionType === "view";
   const viewQuery = extractViewQueryFromSchema(zodSchema);
   if (isView) {
@@ -1856,9 +1672,8 @@ async function ensureTsxLoader() {
   }
 }
 function discoverSchemaFiles(config) {
-  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
-  const mergedConfig = mergeConfig(normalizedConfig);
-  const schemaDir = resolveSchemaDir(normalizedConfig);
+  const mergedConfig = mergeConfig(config);
+  const schemaDir = resolveSchemaDir(config);
   try {
     if (!fs10__namespace.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
@@ -1886,7 +1701,7 @@ function discoverSchemaFiles(config) {
       `(${mergedConfig.includeExtensions.map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`
     );
     return schemaFiles.map((file) => {
-      return path8__namespace.join(schemaDir, file.replace(extensionRemovalRegex, ""));
+      return path7__namespace.join(schemaDir, file.replace(extensionRemovalRegex, ""));
     });
   } catch (error) {
     if (error instanceof FileSystemError) {
@@ -1938,7 +1753,7 @@ Alternatively, compile your schema files to JavaScript first.`,
         );
       }
     }
-    const fileUrl = new URL(`file://${path8__namespace.resolve(resolvedPath)}`);
+    const fileUrl = new URL(`file://${path7__namespace.resolve(resolvedPath)}`);
     const module = await import(fileUrl.href);
     return module;
   } catch (error) {
@@ -1965,13 +1780,13 @@ Alternatively, compile your schema files to JavaScript first.`,
 }
 
 // src/migration/analyzer/index.ts
-async function buildSchemaDefinition(config) {
-  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
-  const mergedConfig = mergeConfig(normalizedConfig);
+async function parseSchemaFiles(config) {
+  const mergedConfig = mergeConfig(config);
   const collections = /* @__PURE__ */ new Map();
-  const schemaFiles = discoverSchemaFiles(normalizedConfig);
+  const collectionSources = /* @__PURE__ */ new Map();
+  const schemaFiles = discoverSchemaFiles(config);
   if (schemaFiles.length === 0) {
-    const schemaDir = resolveSchemaDir(normalizedConfig);
+    const schemaDir = resolveSchemaDir(config);
     throw new SchemaParsingError(
       `No schema files found in ${schemaDir}. Make sure you have schema files in the directory.`,
       schemaDir
@@ -1980,8 +1795,8 @@ async function buildSchemaDefinition(config) {
   for (const filePath of schemaFiles) {
     try {
       let importPath = filePath;
-      if (normalizedConfig.pathTransformer) {
-        importPath = normalizedConfig.pathTransformer(filePath);
+      if (config.pathTransformer) {
+        importPath = config.pathTransformer(filePath);
       } else if (mergedConfig.useCompiledFiles) {
         const distPath = filePath.replace(/\/src\//, "/dist/");
         if (fs10__namespace.existsSync(`${distPath}.js`) || fs10__namespace.existsSync(`${distPath}.mjs`)) {
@@ -1990,17 +1805,25 @@ async function buildSchemaDefinition(config) {
           importPath = filePath;
         }
       }
-      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...`);
+      const module = await importSchemaModule(importPath, config);
+      const collectionExport = selectCollectionSchema(module);
+      if (!collectionExport) {
+        console.warn(
+          `${filePath}: no export carries collection metadata (use defineCollection()/defineView()); skipping. If this file previously produced a collection, the diff may now propose deleting it.`
+        );
         continue;
       }
-      const collectionNameFromSchema = extractCollectionNameFromSchema(zodSchema);
-      const collectionName = collectionNameFromSchema ?? getCollectionNameFromFile(filePath);
-      const collectionSchema = convertZodSchemaToCollectionSchema(collectionName, zodSchema);
+      const { collectionName, schema } = collectionExport;
+      const existingSource = collectionSources.get(collectionName);
+      if (existingSource) {
+        throw new SchemaParsingError(
+          `Collection "${collectionName}" is declared in both ${existingSource} and ${filePath}. Collection names must be unique across schema files.`,
+          filePath
+        );
+      }
+      const collectionSchema = convertZodSchemaToCollectionSchema(collectionName, schema);
       collections.set(collectionName, collectionSchema);
+      collectionSources.set(collectionName, filePath);
     } catch (error) {
       if (error instanceof SchemaParsingError) {
         throw error;
@@ -2014,9 +1837,6 @@ async function buildSchemaDefinition(config) {
   }
   return { collections };
 }
-async function parseSchemaFiles(config) {
-  return buildSchemaDefinition(config);
-}
 
 // src/migration/engine/fields.ts
 var Field = class {
@@ -2062,12 +1882,26 @@ var FIELD_CONSTRUCTORS = {
   AutodateField,
   PasswordField
 };
-function generateRuntimeFieldId(type) {
-  let digits = "";
-  for (let i = 0; i < 10; i++) {
-    digits += Math.floor(Math.random() * 10).toString();
+var crcTable = null;
+function crc32(input) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+      let c = i;
+      for (let bit = 0; bit < 8; bit++) {
+        c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      }
+      crcTable[i] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of new TextEncoder().encode(input)) {
+    crc = crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
   }
-  return `${type || "field"}${digits}`;
+  return (crc ^ 4294967295) >>> 0;
+}
+function generateRuntimeFieldId(type, name) {
+  return `${type || "field"}${crc32(name)}`;
 }
 
 // src/migration/engine/fields-list.ts
@@ -2075,22 +1909,19 @@ var FieldsList = class {
   items = [];
   constructor(fields) {
     if (Array.isArray(fields)) {
-      for (const field of fields) {
-        this.items.push(field instanceof Field ? field : new Field(field));
-      }
+      this.add(...fields);
     }
   }
   get length() {
     return this.items.length;
   }
   /**
-   * Appends fields; a field whose id matches an existing entry replaces it
-   * in place (position preserved), matching PocketBase upsert semantics.
+   * Appends fields; a field that matches an existing entry replaces it in
+   * place (position preserved), matching PocketBase upsert semantics.
    */
   add(...fields) {
     for (const raw of fields) {
-      const field = raw instanceof Field ? raw : new Field(raw);
-      const existing = this.indexOfId(field.id);
+      const { field, existing } = this.resolveIncoming(raw);
       if (existing >= 0) {
         this.items[existing] = field;
       } else {
@@ -2099,15 +1930,14 @@ var FieldsList = class {
     }
   }
   /**
-   * Inserts fields at a position. A field with an already-present id is
+   * Inserts fields at a position. A field matching an already-present entry is
    * moved: the old entry is removed first, then the field is inserted at
    * the requested position.
    */
   addAt(position, ...fields) {
     let insertAt = Math.max(0, Math.min(position, this.items.length));
     for (const raw of fields) {
-      const field = raw instanceof Field ? raw : new Field(raw);
-      const existing = this.indexOfId(field.id);
+      const { field, existing } = this.resolveIncoming(raw);
       if (existing >= 0) {
         this.items.splice(existing, 1);
         if (existing < insertAt) {
@@ -2119,6 +1949,36 @@ var FieldsList = class {
       insertAt++;
     }
   }
+  /**
+   * Materializes an incoming field and locates the entry it replaces.
+   *
+   * PocketBase's rule (documented on `FieldsList.Add` in types.d.ts): match by
+   * id, "or by their name if the new field doesn't have an explicit id", and
+   * autogenerate a missing id from the name. Matching by id alone turns the
+   * idiomatic `fields.add(new TextField({name: "title", max: 500}))` — no id,
+   * meant to rewrite `title` — into a second field also called `title`, which
+   * PocketBase would reject on save but the engine used to accept, corrupting
+   * the reconstructed state.
+   *
+   * On a name match the *existing* id is kept rather than replaced with the
+   * derived one. For a collection PocketBase authored the two are identical
+   * (its auto-ids already are `<type><crc32(name)>`); they diverge only when
+   * the stored field carries a hand-assigned id, and there preserving it keeps
+   * a later `removeById`/`getById` in the same migration working.
+   */
+  resolveIncoming(raw) {
+    const field = raw instanceof Field ? raw : new Field(raw);
+    const hasExplicitId = typeof field.id === "string" && field.id !== "";
+    if (hasExplicitId) {
+      return { field, existing: this.indexOfId(field.id) };
+    }
+    const existing = this.items.findIndex((f) => f.name === field.name);
+    field.id = existing >= 0 ? this.items[existing].id : generateRuntimeFieldId(
+      typeof field.type === "string" ? field.type : "",
+      typeof field.name === "string" ? field.name : ""
+    );
+    return { field, existing };
+  }
   removeById(id) {
     const index = this.indexOfId(id);
     if (index >= 0) {
@@ -2131,12 +1991,18 @@ var FieldsList = class {
       this.items.splice(index, 1);
     }
   }
+  /**
+   * Null rather than undefined for a miss: these two return a Go `Field`
+   * interface, and goja surfaces a nil interface to JavaScript as `null`. A
+   * migration written as `if (collection.fields.getByName("x") === null)` has
+   * to take the same branch here as it does in production.
+   */
   getById(id) {
     const index = this.indexOfId(id);
-    return index >= 0 ? this.items[index] : void 0;
+    return index >= 0 ? this.items[index] : null;
   }
   getByName(name) {
-    return this.items.find((f) => f.name === name);
+    return this.items.find((f) => f.name === name) ?? null;
   }
   at(index) {
     return this.items.at(index);
@@ -2161,9 +2027,14 @@ var FieldsList = class {
     this.items = [];
     this.add(...fields);
   }
-  /** Plain objects, in order */
+  /**
+   * Plain objects, in order — copied deeply, so option arrays like a select
+   * field's `values` are not shared with the live list. A shallow spread let a
+   * snapshot handed to the diff engine alias engine state, where an in-place
+   * sort or push downstream would silently rewrite the collection it came from.
+   */
   serialize() {
-    return this.items.map((field) => ({ ...field }));
+    return this.items.map((field) => copyPlainData({ ...field }));
   }
   indexOfId(id) {
     if (typeof id !== "string" || id === "") {
@@ -2172,6 +2043,22 @@ var FieldsList = class {
     return this.items.findIndex((f) => f.id === id);
   }
 };
+function copyPlainData(value) {
+  if (Array.isArray(value)) {
+    return value.map(copyPlainData);
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype || prototype === null) {
+      const copy = {};
+      for (const [key, entry] of Object.entries(value)) {
+        copy[key] = copyPlainData(entry);
+      }
+      return copy;
+    }
+  }
+  return value;
+}
 
 // src/migration/engine/collection.ts
 var AUTH_SYSTEM_FIELDS = [
@@ -3590,6 +3477,13 @@ function createInertStub(name, options, warn) {
       if (prop === "then") {
         return void 0;
       }
+      if (prop === "length") {
+        return 0;
+      }
+      if (prop === Symbol.iterator) {
+        return function* emptyIterator() {
+        };
+      }
       if (typeof prop === "symbol") {
         return void 0;
       }
@@ -3648,7 +3542,10 @@ var SimulatedAppImpl = class {
     ensureAuthSystemFields(collection);
     for (const field of collection.fields) {
       if (typeof field.id !== "string" || field.id === "") {
-        field.id = generateRuntimeFieldId(typeof field.type === "string" ? field.type : "");
+        field.id = generateRuntimeFieldId(
+          typeof field.type === "string" ? field.type : "",
+          typeof field.name === "string" ? field.name : ""
+        );
       }
     }
     this.store.upsert(collection);
@@ -3934,21 +3831,21 @@ function appliedMigrationsFromList(files, origin = "<list>") {
   const entries = [];
   const coreEntries = [];
   for (const file of files) {
-    const entry = { file: path8__namespace.basename(file) };
+    const entry = { file: path7__namespace.basename(file) };
     (isCoreMigration(entry.file) ? coreEntries : entries).push(entry);
   }
   return { origin, entries, coreEntries };
 }
 function defaultDataDirectory(migrationsPath) {
-  return path8__namespace.resolve(path8__namespace.dirname(path8__namespace.resolve(migrationsPath)), "pb_data");
+  return path7__namespace.resolve(path7__namespace.dirname(path7__namespace.resolve(migrationsPath)), "pb_data");
 }
 function resolveDatabasePath(dataPathOrFile) {
-  const resolved = path8__namespace.resolve(dataPathOrFile);
+  const resolved = path7__namespace.resolve(dataPathOrFile);
   if (!fs10__namespace.existsSync(resolved)) {
     return null;
   }
   if (fs10__namespace.statSync(resolved).isDirectory()) {
-    const candidate = path8__namespace.join(resolved, POCKETBASE_DATABASE_FILENAME);
+    const candidate = path7__namespace.join(resolved, POCKETBASE_DATABASE_FILENAME);
     return fs10__namespace.existsSync(candidate) ? candidate : null;
   }
   return resolved;
@@ -3957,7 +3854,7 @@ function readAppliedMigrations(dataPathOrFile) {
   const databasePath = resolveDatabasePath(dataPathOrFile);
   if (!databasePath) {
     throw new AppliedMigrationsError(
-      `No PocketBase database found at ${path8__namespace.resolve(dataPathOrFile)}. Expected a data.db file, or a pb_data directory containing one.`,
+      `No PocketBase database found at ${path7__namespace.resolve(dataPathOrFile)}. Expected a data.db file, or a pb_data directory containing one.`,
       dataPathOrFile
     );
   }
@@ -4073,7 +3970,7 @@ function discoverMigrations(migrationsPath) {
       continue;
     }
     discovered.push({
-      path: path8__namespace.join(migrationsPath, name),
+      path: path7__namespace.join(migrationsPath, name),
       name,
       timestamp,
       isSnapshot: name.endsWith("_collections_snapshot.js") || name.endsWith("_snapshot.js")
@@ -4352,8 +4249,8 @@ function replayMigrationsDirectory(migrationsPath, options = {}) {
   }
   return replayMigrations(plan.filesToReplay, { ...engineOptions, plan });
 }
-({
-  workspaceRoot: process.cwd()});
+
+// src/migration/snapshot.ts
 function loadSnapshotWithMigrations(config = {}) {
   const migrationsPath = config.migrationsPath;
   if (!migrationsPath) {
@@ -4382,16 +4279,13 @@ function loadSnapshotWithMigrations(config = {}) {
 }
 
 // src/migration/diff/config.ts
-var DEFAULT_CONFIG3 = {
-  warnOnDelete: true,
-  requireForceForDestructive: true,
-  severityThreshold: "high",
+var DEFAULT_CONFIG2 = {
   systemCollections: ["_mfas", "_otps", "_externalAuths", "_authOrigins", "_superusers"],
   usersSystemFields: ["id", "password", "tokenKey", "email", "emailVisibility", "verified", "created", "updated"]
 };
 function mergeConfig2(config) {
   return {
-    ...DEFAULT_CONFIG3,
+    ...DEFAULT_CONFIG2,
     ...config
   };
 }
@@ -4420,40 +4314,23 @@ function areValuesEqual(a, b) {
   }
   return a === b;
 }
-var OPTION_ZERO_VALUES = {
-  autogeneratePattern: "",
-  pattern: "",
-  primaryKey: false,
-  convertURLs: false,
-  cost: 0,
-  hidden: false,
-  presentable: false,
-  system: false
-};
 function normalizeOptionValue(key, value, fieldType) {
-  if (OPTION_ZERO_VALUES[key] !== void 0 && value === OPTION_ZERO_VALUES[key]) {
+  if (value === null || value === void 0) {
     return void 0;
   }
-  if (key === "maxSelect" && value === 1 && (fieldType === "select" || fieldType === "file")) {
+  const unsetValue = getFieldOptionUnsetValue(fieldType, key);
+  if (unsetValue !== void 0 && areValuesEqual(value, unsetValue)) {
     return void 0;
   }
-  if (key === "maxSize" && value === 0 && fieldType === "file") {
+  if (key === "values" && fieldType === "select" && Array.isArray(value)) {
+    return [...value].sort();
+  }
+  if (key === "maxSelect" && value === 1 && (fieldType === "select" || fieldType === "file")) {
     return void 0;
   }
   if (key === "min" && value === 1 && fieldType === "number") {
     return void 0;
   }
-  if (fieldType === "file") {
-    if (key === "mimeTypes" && Array.isArray(value) && value.length === 0) {
-      return void 0;
-    }
-    if (key === "thumbs" && Array.isArray(value) && value.length === 0) {
-      return void 0;
-    }
-    if (key === "protected" && value === false) {
-      return void 0;
-    }
-  }
   if (fieldType === "autodate") {
     if (key === "onCreate" && value === true) {
       return void 0;
@@ -4863,57 +4740,6 @@ function buildCollectionModification(currentCollection, previousCollection, conf
   };
 }
 
-// src/migration/diff/summary.ts
-function categorizeChangesBySeverity(diff, _config) {
-  const destructive = [];
-  const nonDestructive = [];
-  for (const collection of diff.collectionsToDelete) {
-    if (collection.type === "view") {
-      nonDestructive.push(`Delete view collection: ${collection.name}`);
-    } else {
-      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}`);
-    }
-    if (modification.viewQueryUpdate) {
-      nonDestructive.push(`Update view query: ${collectionName}`);
-    }
-  }
-  return { destructive, nonDestructive };
-}
-
 // src/migration/diff/filter.ts
 function matchesPattern(text, patterns) {
   if (!patterns || patterns.length === 0) return true;
@@ -4990,25 +4816,76 @@ function filterDiff(diff, options) {
   };
 }
 
-// src/migration/diff/index.ts
-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 || modification.viewQueryUpdate !== void 0;
-}
-function aggregateChanges(currentSchema, previousSnapshot, config) {
-  const collectionIdToName = /* @__PURE__ */ new Map();
-  if (previousSnapshot) {
-    for (const [name, collection] of previousSnapshot.collections) {
-      if (collection.id) {
-        collectionIdToName.set(collection.id, name);
-      }
+// src/migration/diff/summary.ts
+function categorizeChangesBySeverity(diff, _config) {
+  const destructive = [];
+  const nonDestructive = [];
+  for (const collection of diff.collectionsToDelete) {
+    if (collection.type === "view") {
+      nonDestructive.push(`Delete view collection: ${collection.name}`);
+    } else {
+      destructive.push(`Delete collection: ${collection.name}`);
     }
   }
-  const collectionsToCreate = findNewCollections(currentSchema, previousSnapshot);
-  const collectionsToDelete = findRemovedCollections(currentSchema, previousSnapshot);
-  const filteredCollectionsToCreate = collectionsToCreate.filter(
-    (collection) => !isSystemCollection(collection.name, config)
-  );
-  const filteredCollectionsToDelete = collectionsToDelete.filter(
+  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}`);
+    }
+    if (modification.viewQueryUpdate) {
+      nonDestructive.push(`Update view query: ${collectionName}`);
+    }
+  }
+  return { destructive, nonDestructive };
+}
+
+// src/migration/diff/index.ts
+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 || modification.viewQueryUpdate !== void 0;
+}
+function compare2(currentSchema, previousSnapshot, config) {
+  const collectionIdToName = /* @__PURE__ */ new Map();
+  if (previousSnapshot) {
+    for (const [name, collection] of previousSnapshot.collections) {
+      if (collection.id) {
+        collectionIdToName.set(collection.id, name);
+      }
+    }
+  }
+  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 registry = new CollectionIdRegistry();
@@ -5046,8 +4923,153 @@ function aggregateChanges(currentSchema, previousSnapshot, config) {
     existingCollectionIds
   };
 }
-function compare2(currentSchema, previousSnapshot, config) {
-  return aggregateChanges(currentSchema, previousSnapshot, config);
+
+// src/migration/validation.ts
+function detectCollectionDeletions(diff) {
+  const changes = [];
+  for (const collection of diff.collectionsToDelete) {
+    if (collection.type === "view") {
+      continue;
+    }
+    changes.push({
+      type: "collection_deletion" /* COLLECTION_DELETION */,
+      description: `Delete collection: ${collection.name}`,
+      collection: collection.name,
+      severity: "high",
+      warning: `All data in the "${collection.name}" collection will be permanently deleted.`
+    });
+  }
+  return changes;
+}
+function detectFieldDeletions(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const field of modification.fieldsToRemove) {
+      changes.push({
+        type: "field_deletion" /* FIELD_DELETION */,
+        description: `Delete field: ${modification.collection}.${field.name}`,
+        collection: modification.collection,
+        field: field.name,
+        severity: "high",
+        warning: `All data in the "${field.name}" field of "${modification.collection}" will be permanently deleted.`
+      });
+    }
+  }
+  return changes;
+}
+function detectFieldTypeChanges(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const fieldMod of modification.fieldsToModify) {
+      const typeChange = fieldMod.changes.find((c) => c.property === "type");
+      if (typeChange) {
+        changes.push({
+          type: "field_type_change" /* FIELD_TYPE_CHANGE */,
+          description: `Change field type: ${modification.collection}.${fieldMod.fieldName}`,
+          collection: modification.collection,
+          field: fieldMod.fieldName,
+          details: {
+            oldValue: typeChange.oldValue,
+            newValue: typeChange.newValue
+          },
+          severity: "high",
+          warning: `Changing field type from "${typeChange.oldValue}" to "${typeChange.newValue}" may cause data loss or conversion errors.`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function detectFieldRequiredChanges(diff) {
+  const changes = [];
+  for (const modification of diff.collectionsToModify) {
+    for (const fieldMod of modification.fieldsToModify) {
+      const requiredChange = fieldMod.changes.find(
+        (c) => c.property === "required" && c.newValue === true && c.oldValue === false
+      );
+      if (requiredChange) {
+        changes.push({
+          type: "field_required_change" /* FIELD_REQUIRED_CHANGE */,
+          description: `Make field required: ${modification.collection}.${fieldMod.fieldName}`,
+          collection: modification.collection,
+          field: fieldMod.fieldName,
+          details: {
+            oldValue: false,
+            newValue: true
+          },
+          severity: "medium",
+          warning: `Making "${fieldMod.fieldName}" required may cause issues with existing records that have null/empty values.`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function detectDestructiveChanges(diff) {
+  const changes = [];
+  changes.push(...detectCollectionDeletions(diff));
+  changes.push(...detectFieldDeletions(diff));
+  changes.push(...detectFieldTypeChanges(diff));
+  changes.push(...detectFieldRequiredChanges(diff));
+  return changes;
+}
+function formatDestructiveChanges(changes) {
+  if (changes.length === 0) {
+    return "No destructive changes detected.";
+  }
+  const lines = [];
+  const highSeverity = changes.filter((c) => c.severity === "high");
+  const mediumSeverity = changes.filter((c) => c.severity === "medium");
+  const lowSeverity = changes.filter((c) => c.severity === "low");
+  if (highSeverity.length > 0) {
+    lines.push("\u{1F534} HIGH SEVERITY CHANGES (Data Loss Risk):");
+    lines.push("");
+    for (const change of highSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
+      if (change.details) {
+        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
+          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (mediumSeverity.length > 0) {
+    lines.push("\u{1F7E1} MEDIUM SEVERITY CHANGES (Potential Issues):");
+    lines.push("");
+    for (const change of mediumSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
+      if (change.details) {
+        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
+          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (lowSeverity.length > 0) {
+    lines.push("\u{1F7E2} LOW SEVERITY CHANGES:");
+    lines.push("");
+    for (const change of lowSeverity) {
+      lines.push(`  \u2022 ${change.description}`);
+      lines.push(`    \u2139\uFE0F  ${change.warning}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function summarizeDestructiveChanges(changes) {
+  return {
+    total: changes.length,
+    high: changes.filter((c) => c.severity === "high").length,
+    medium: changes.filter((c) => c.severity === "medium").length,
+    low: changes.filter((c) => c.severity === "low").length
+  };
+}
+function requiresForceFlag(changes) {
+  return changes.some((c) => c.severity === "high" || c.severity === "medium");
 }
 
 // src/migration/generator/config.ts
@@ -5058,7 +5080,7 @@ migrate((app) => {
 {{DOWN_CODE}}
 });
 `;
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG3 = {
   workspaceRoot: process.cwd(),
   timestampGenerator: () => Math.floor(Date.now() / 1e3).toString(),
   template: DEFAULT_TEMPLATE,
@@ -5067,20 +5089,20 @@ var DEFAULT_CONFIG4 = {
 };
 function mergeConfig3(config) {
   return {
-    ...DEFAULT_CONFIG4,
+    ...DEFAULT_CONFIG3,
     force: false,
     ...config
   };
 }
 function resolveMigrationDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path8__namespace.isAbsolute(config.migrationDir)) {
+  if (path7__namespace.isAbsolute(config.migrationDir)) {
     return config.migrationDir;
   }
-  return path8__namespace.join(workspaceRoot, config.migrationDir);
+  return path7__namespace.join(workspaceRoot, config.migrationDir);
 }
 function createMigrationFileStructure(upCode, downCode, config) {
-  const mergedConfig = config ? mergeConfig3(config) : DEFAULT_CONFIG4;
+  const mergedConfig = config ? mergeConfig3(config) : DEFAULT_CONFIG3;
   let template = mergedConfig.template;
   template = template.replace("{{TYPES_PATH}}", () => mergedConfig.typesPath);
   template = template.replace("{{UP_CODE}}", () => upCode);
@@ -5115,7 +5137,7 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path8__namespace.join(migrationDir, filename);
+    const filePath = path7__namespace.join(migrationDir, filename);
     fs10__namespace.writeFileSync(filePath, content, "utf-8");
     return filePath;
   } catch (error) {
@@ -5123,7 +5145,7 @@ function writeMigrationFile(migrationDir, filename, content) {
       throw error;
     }
     const fsError = error;
-    const filePath = path8__namespace.join(migrationDir, filename);
+    const filePath = path7__namespace.join(migrationDir, filename);
     if (fsError.code === "EACCES" || fsError.code === "EPERM") {
       throw new FileSystemError(
         `Permission denied writing migration file. Check file and directory permissions.`,
@@ -5273,13 +5295,16 @@ function generateFieldModification(collectionName, modification, varName, isLast
   const lines = [];
   const collectionVar = varName || `collection_${collectionName}_${modification.fieldName}`;
   const fieldVar = `${collectionVar}_field`;
+  const fieldType = modification.newDefinition?.type ?? modification.currentDefinition?.type;
   lines.push(`  const ${collectionVar} = ${generateFindCollectionCode(collectionName, collectionIdMap)};`);
   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)};`);
+      const newValue = change.newValue === void 0 ? getFieldOptionUnsetValue(fieldType, optionKey) : change.newValue;
+      const pbKey = fieldType === "number" && optionKey === "noDecimal" ? "onlyInt" : optionKey;
+      lines.push(`  ${fieldVar}.${pbKey} = ${formatValue(newValue)};`);
     } else if (change.property.startsWith("relation.")) {
       const relationKey = change.property.replace("relation.", "");
       if (relationKey === "collection") {
@@ -5887,7 +5912,7 @@ function planMigrations(diff, config) {
     const planned = [];
     let existingFiles = [];
     if (!normalizedConfig.force && fs10__namespace.existsSync(migrationDir)) {
-      existingFiles = fs10__namespace.readdirSync(migrationDir).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).map((f) => fs10__namespace.readFileSync(path8__namespace.join(migrationDir, f), "utf-8"));
+      existingFiles = fs10__namespace.readdirSync(migrationDir).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).map((f) => fs10__namespace.readFileSync(path7__namespace.join(migrationDir, f), "utf-8"));
     }
     for (const operation of operations) {
       const upCode = generateOperationUpMigration(operation, collectionIdMap);
@@ -6644,154 +6669,6 @@ function toPhaseError(error, fallbackPhase) {
   }
   return { phase: fallbackPhase, message: error instanceof Error ? error.message : String(error) };
 }
-
-// src/migration/validation.ts
-function detectCollectionDeletions(diff) {
-  const changes = [];
-  for (const collection of diff.collectionsToDelete) {
-    if (collection.type === "view") {
-      continue;
-    }
-    changes.push({
-      type: "collection_deletion" /* COLLECTION_DELETION */,
-      description: `Delete collection: ${collection.name}`,
-      collection: collection.name,
-      severity: "high",
-      warning: `All data in the "${collection.name}" collection will be permanently deleted.`
-    });
-  }
-  return changes;
-}
-function detectFieldDeletions(diff) {
-  const changes = [];
-  for (const modification of diff.collectionsToModify) {
-    for (const field of modification.fieldsToRemove) {
-      changes.push({
-        type: "field_deletion" /* FIELD_DELETION */,
-        description: `Delete field: ${modification.collection}.${field.name}`,
-        collection: modification.collection,
-        field: field.name,
-        severity: "high",
-        warning: `All data in the "${field.name}" field of "${modification.collection}" will be permanently deleted.`
-      });
-    }
-  }
-  return changes;
-}
-function detectFieldTypeChanges(diff) {
-  const changes = [];
-  for (const modification of diff.collectionsToModify) {
-    for (const fieldMod of modification.fieldsToModify) {
-      const typeChange = fieldMod.changes.find((c) => c.property === "type");
-      if (typeChange) {
-        changes.push({
-          type: "field_type_change" /* FIELD_TYPE_CHANGE */,
-          description: `Change field type: ${modification.collection}.${fieldMod.fieldName}`,
-          collection: modification.collection,
-          field: fieldMod.fieldName,
-          details: {
-            oldValue: typeChange.oldValue,
-            newValue: typeChange.newValue
-          },
-          severity: "high",
-          warning: `Changing field type from "${typeChange.oldValue}" to "${typeChange.newValue}" may cause data loss or conversion errors.`
-        });
-      }
-    }
-  }
-  return changes;
-}
-function detectFieldRequiredChanges(diff) {
-  const changes = [];
-  for (const modification of diff.collectionsToModify) {
-    for (const fieldMod of modification.fieldsToModify) {
-      const requiredChange = fieldMod.changes.find(
-        (c) => c.property === "required" && c.newValue === true && c.oldValue === false
-      );
-      if (requiredChange) {
-        changes.push({
-          type: "field_required_change" /* FIELD_REQUIRED_CHANGE */,
-          description: `Make field required: ${modification.collection}.${fieldMod.fieldName}`,
-          collection: modification.collection,
-          field: fieldMod.fieldName,
-          details: {
-            oldValue: false,
-            newValue: true
-          },
-          severity: "medium",
-          warning: `Making "${fieldMod.fieldName}" required may cause issues with existing records that have null/empty values.`
-        });
-      }
-    }
-  }
-  return changes;
-}
-function detectDestructiveChanges(diff) {
-  const changes = [];
-  changes.push(...detectCollectionDeletions(diff));
-  changes.push(...detectFieldDeletions(diff));
-  changes.push(...detectFieldTypeChanges(diff));
-  changes.push(...detectFieldRequiredChanges(diff));
-  return changes;
-}
-function formatDestructiveChanges(changes) {
-  if (changes.length === 0) {
-    return "No destructive changes detected.";
-  }
-  const lines = [];
-  const highSeverity = changes.filter((c) => c.severity === "high");
-  const mediumSeverity = changes.filter((c) => c.severity === "medium");
-  const lowSeverity = changes.filter((c) => c.severity === "low");
-  if (highSeverity.length > 0) {
-    lines.push("\u{1F534} HIGH SEVERITY CHANGES (Data Loss Risk):");
-    lines.push("");
-    for (const change of highSeverity) {
-      lines.push(`  \u2022 ${change.description}`);
-      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
-      if (change.details) {
-        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
-          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
-        }
-      }
-      lines.push("");
-    }
-  }
-  if (mediumSeverity.length > 0) {
-    lines.push("\u{1F7E1} MEDIUM SEVERITY CHANGES (Potential Issues):");
-    lines.push("");
-    for (const change of mediumSeverity) {
-      lines.push(`  \u2022 ${change.description}`);
-      lines.push(`    \u26A0\uFE0F  ${change.warning}`);
-      if (change.details) {
-        if (change.details.oldValue !== void 0 && change.details.newValue !== void 0) {
-          lines.push(`    Old: ${change.details.oldValue} \u2192 New: ${change.details.newValue}`);
-        }
-      }
-      lines.push("");
-    }
-  }
-  if (lowSeverity.length > 0) {
-    lines.push("\u{1F7E2} LOW SEVERITY CHANGES:");
-    lines.push("");
-    for (const change of lowSeverity) {
-      lines.push(`  \u2022 ${change.description}`);
-      lines.push(`    \u2139\uFE0F  ${change.warning}`);
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-function summarizeDestructiveChanges(changes) {
-  return {
-    total: changes.length,
-    high: changes.filter((c) => c.severity === "high").length,
-    medium: changes.filter((c) => c.severity === "medium").length,
-    low: changes.filter((c) => c.severity === "low").length
-  };
-}
-function requiresForceFlag(changes) {
-  return changes.some((c) => c.severity === "high" || c.severity === "medium");
-}
 var CONFIG_FILE_NAMES = [
   "pocketbase-migrate.config.js",
   "pocketbase-migrate.config.mjs",
@@ -6800,7 +6677,7 @@ var CONFIG_FILE_NAMES = [
   "migrate.config.mjs",
   "migrate.config.json"
 ];
-var DEFAULT_CONFIG5 = {
+var DEFAULT_CONFIG4 = {
   schema: {
     directory: "src/schema",
     exclude: ["base.ts", "index.ts", "permissions.ts", "permission-templates.ts"]
@@ -6821,7 +6698,7 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path8__namespace.join(directory, fileName);
+    const filePath = path7__namespace.join(directory, fileName);
     if (fs10__namespace.existsSync(filePath)) {
       return filePath;
     }
@@ -6862,7 +6739,7 @@ async function loadConfigFile(configPath) {
   if (!fs10__namespace.existsSync(configPath)) {
     return null;
   }
-  const ext = path8__namespace.extname(configPath).toLowerCase();
+  const ext = path7__namespace.extname(configPath).toLowerCase();
   if (ext === ".json") {
     return loadJsonConfig(configPath);
   } else if (ext === ".js" || ext === ".mjs") {
@@ -6957,8 +6834,8 @@ function validateConfig(config, configPath) {
   }
   const cwd = process.cwd();
   const possiblePaths = [
-    path8__namespace.resolve(cwd, config.schema.directory),
-    path8__namespace.resolve(cwd, "shared", config.schema.directory)
+    path7__namespace.resolve(cwd, config.schema.directory),
+    path7__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
   const schemaDir = possiblePaths.find((p) => fs10__namespace.existsSync(p));
   if (!schemaDir) {
@@ -6968,17 +6845,17 @@ function validateConfig(config, configPath) {
   }
 }
 async function loadConfig(options = {}) {
-  let config = { ...DEFAULT_CONFIG5 };
+  let config = { ...DEFAULT_CONFIG4 };
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path8__namespace.resolve(cwd, options.config);
+    const explicitPath = path7__namespace.resolve(cwd, options.config);
     if (!fs10__namespace.existsSync(explicitPath)) {
       throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
     }
     configFilePath = explicitPath;
   } else {
-    const searchDirs = [cwd, path8__namespace.join(cwd, "shared")];
+    const searchDirs = [cwd, path7__namespace.join(cwd, "shared")];
     for (const dir of searchDirs) {
       if (fs10__namespace.existsSync(dir)) {
         const found = findConfigFile(dir);
@@ -7009,23 +6886,23 @@ async function loadConfig(options = {}) {
 function getSchemaDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path8__namespace.resolve(cwd, config.schema.directory),
-    path8__namespace.resolve(cwd, "shared", config.schema.directory)
+    path7__namespace.resolve(cwd, config.schema.directory),
+    path7__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
   return possiblePaths.find((p) => fs10__namespace.existsSync(p)) || possiblePaths[0];
 }
 function getMigrationsDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path8__namespace.resolve(cwd, config.migrations.directory),
-    path8__namespace.resolve(cwd, "shared", config.migrations.directory)
+    path7__namespace.resolve(cwd, config.migrations.directory),
+    path7__namespace.resolve(cwd, "shared", config.migrations.directory)
   ];
   return possiblePaths.find((p) => fs10__namespace.existsSync(p)) || possiblePaths[0];
 }
 function getDataDirectory(config) {
   const configured = config.migrations.dataDirectory.trim();
   if (configured !== "") {
-    return path8__namespace.resolve(process.cwd(), configured);
+    return path7__namespace.resolve(process.cwd(), configured);
   }
   return defaultDataDirectory(getMigrationsDirectory(config));
 }
@@ -7324,8 +7201,7 @@ async function executeGenerate(filters, options) {
     logSuccess(`Found ${currentSchema.collections.size} collection(s)`);
     logInfo("Loading previous snapshot...");
     const previousSnapshot = loadSnapshotWithMigrations({
-      migrationsPath: migrationsDir,
-      workspaceRoot: process.cwd()
+      migrationsPath: migrationsDir
     });
     if (!previousSnapshot) {
       logInfo("No previous snapshot found - treating as empty database (first-time generation)");
@@ -7378,7 +7254,7 @@ async function executeGenerate(filters, options) {
     }
     const migrationPaths = writePlannedMigrations(planned, migrationsDir);
     if (migrationPaths.length === 1) {
-      logSuccess(`Migration file created: ${path8__namespace.basename(migrationPaths[0])}`);
+      logSuccess(`Migration file created: ${path7__namespace.basename(migrationPaths[0])}`);
     } else {
       logSuccess(`Created ${migrationPaths.length} migration files`);
     }
@@ -7404,7 +7280,7 @@ async function executeGenerate(filters, options) {
       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"');
+      console.log("  \u2022 Check that each schema file exports a defineCollection()/defineView() result (default export preferred)");
     } else if (error instanceof SnapshotError) {
       logError("Snapshot Error");
       console.error();
@@ -7754,13 +7630,13 @@ async function executeGenerateTypes(options) {
     const generator = new TypeGenerator(currentSchema);
     const output = await withProgress("Generating TypeScript definitions...", () => Promise.resolve(generator.generate()));
     const outputPath = options.output || config.typeGen.outPath;
-    const resolvedPath = path8__namespace.resolve(process.cwd(), outputPath);
+    const resolvedPath = path7__namespace.resolve(process.cwd(), outputPath);
     fs10__namespace.writeFileSync(resolvedPath, output);
     logSuccess(`Types generated successfully at: ${outputPath}`);
     logSection("\u2705 Next Steps");
     console.log();
     console.log("  1. Import types in your application:");
-    console.log(`     import { TypedPocketBase } from "./${path8__namespace.basename(outputPath).replace(/\.ts$/, "")}";`);
+    console.log(`     import { TypedPocketBase } from "./${path7__namespace.basename(outputPath).replace(/\.ts$/, "")}";`);
     console.log();
   } catch (error) {
     logError(`Failed to generate types: ${error}`);
@@ -7782,14 +7658,14 @@ function collectExecutionWarnings(files) {
       const result = executeMigrationFile(file, store);
       byFile.set(file, result.warnings);
     } catch (error) {
-      logDebug(`Skipping execution of ${path8__namespace.basename(file)}: ${error}`);
+      logDebug(`Skipping execution of ${path7__namespace.basename(file)}: ${error}`);
       byFile.set(file, []);
     }
   }
   return byFile;
 }
 function reportResult(result) {
-  const name = path8__namespace.basename(result.file);
+  const name = path7__namespace.basename(result.file);
   if (result.findings.length === 0) {
     logDebug(`\u2713 ${name}`);
     return true;
@@ -7815,7 +7691,7 @@ async function executeLint(files, options) {
     }
     const config = await loadConfig(options);
     const migrationsDir = getMigrationsDirectory(config);
-    const targets = files.length > 0 ? files.map((file) => path8__namespace.resolve(process.cwd(), file)) : discoverMigrations(migrationsDir).map((migration) => migration.path);
+    const targets = files.length > 0 ? files.map((file) => path7__namespace.resolve(process.cwd(), file)) : discoverMigrations(migrationsDir).map((migration) => migration.path);
     logSection("\u{1F50E} Checking goja Compatibility");
     console.log();
     if (targets.length === 0) {
@@ -7924,17 +7800,15 @@ function lookupAppliedMigrations(migrationsDir, dataPath) {
     throw error;
   }
 }
-function loadStatusBaselines(currentSchema, migrationsDir, workspaceRoot, applied) {
+function loadStatusBaselines(currentSchema, migrationsDir, applied) {
   const previousSnapshot = loadSnapshotWithMigrations({
-    migrationsPath: migrationsDir,
-    workspaceRoot
+    migrationsPath: migrationsDir
   });
   if (applied?.status !== "found" || applied.plan.inSync) {
     return { previousSnapshot, appliedDiff: null };
   }
   const appliedSnapshot = loadSnapshotWithMigrations({
     migrationsPath: migrationsDir,
-    workspaceRoot,
     appliedMigrations: applied.applied
   });
   return { previousSnapshot, appliedDiff: compare2(currentSchema, appliedSnapshot) };
@@ -8081,7 +7955,7 @@ async function executeStatus(options) {
       process.exit(1);
     }
     logInfo("Loading previous snapshot...");
-    const { previousSnapshot, appliedDiff } = loadStatusBaselines(currentSchema, migrationsDir, process.cwd(), applied);
+    const { previousSnapshot, appliedDiff } = loadStatusBaselines(currentSchema, migrationsDir, applied);
     if (applied?.status === "found" && !isJsonMode) {
       const inSync = reportAppliedMigrations(applied.plan);
       if (!inSync) {
@@ -8183,7 +8057,7 @@ async function executeStatus(options) {
       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"');
+      console.log("  \u2022 Check that each schema file exports a defineCollection()/defineView() result (default export preferred)");
     } else if (error instanceof SnapshotError) {
       logError("Snapshot Error");
       console.error();
@@ -8229,8 +8103,8 @@ Examples:
 function getVersion() {
   try {
     const __filename2 = url.fileURLToPath(importMetaUrl);
-    const __dirname = path8.dirname(__filename2);
-    const packageJsonPath = path8.join(__dirname, "../../package.json");
+    const __dirname = path7.dirname(__filename2);
+    const packageJsonPath = path7.join(__dirname, "../../package.json");
     const packageJson = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
     return packageJson.version || "0.0.0";
   } catch {