pocketbase-zod-schema 1.0.1 → 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;
@@ -506,10 +493,10 @@ 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();
   }
   /**
@@ -805,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) {
@@ -862,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 ?? [];
@@ -1014,115 +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;
-}
-var REFERENCE_NAME_SUFFIXES = /* @__PURE__ */ new Set([
-  "ref",
-  "refs",
-  "id",
-  "ids",
-  "uid",
-  "uids",
-  "uuid",
-  "uuids",
-  "fk",
-  "fks",
-  "pk",
-  "pks"
-]);
-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];
-  if (REFERENCE_NAME_SUFFIXES.has(entityName.toLowerCase())) {
-    throw new Error(buildUnresolvableTargetMessage(fieldName, entityName, matches.slice(0, -1)));
-  }
-  return pluralize(entityName);
-}
-function buildUnresolvableTargetMessage(fieldName, suffix, leadingSegments) {
-  const likelyTarget = leadingSegments.length > 0 ? pluralize(leadingSegments.join("")) : "TargetCollection";
-  return `Cannot infer the relation target for field "${fieldName}": the name ends in "${suffix}", which marks it as a reference without naming the collection it points at. Declare the target explicitly, e.g. ${fieldName}: RelationField({ collection: "${likelyTarget}" }).`;
-}
-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";
@@ -1148,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) {
@@ -1164,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) {
@@ -1194,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") {
@@ -1208,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;
@@ -1231,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;
@@ -1249,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;
@@ -1259,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;
@@ -1424,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;
@@ -1467,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 });
@@ -1715,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) {
@@ -1759,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);
@@ -1770,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,
@@ -1822,7 +1561,7 @@ function extractChainedFieldOptions(fieldType, 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) {
@@ -1933,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");
@@ -1963,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) {
@@ -2015,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) {
@@ -2042,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
@@ -2057,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`)) {
@@ -2067,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;
@@ -2091,9 +1837,6 @@ async function buildSchemaDefinition(config) {
   }
   return { collections };
 }
-async function parseSchemaFiles(config) {
-  return buildSchemaDefinition(config);
-}
 
 // src/migration/engine/fields.ts
 var Field = class {
@@ -4088,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;
@@ -4111,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
     );
   }
@@ -4227,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")
@@ -4506,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) {
@@ -4536,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
   };
 }
@@ -5000,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;
@@ -5127,11 +4816,62 @@ function filterDiff(diff, options) {
   };
 }
 
+// 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/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) {
+function compare2(currentSchema, previousSnapshot, config) {
   const collectionIdToName = /* @__PURE__ */ new Map();
   if (previousSnapshot) {
     for (const [name, collection] of previousSnapshot.collections) {
@@ -5183,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
@@ -5195,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,
@@ -5204,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);
@@ -5252,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) {
@@ -5260,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.`,
@@ -6027,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);
@@ -6784,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",
@@ -6940,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"]
@@ -6961,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;
     }
@@ -7002,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") {
@@ -7097,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) {
@@ -7108,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);
@@ -7149,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));
 }
@@ -7464,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)");
@@ -7518,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`);
     }
@@ -7544,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();
@@ -7894,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}`);
@@ -7922,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;
@@ -7955,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) {
@@ -8064,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) };
@@ -8221,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) {
@@ -8323,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();
@@ -8369,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 {