@momentumcms/migrations 0.3.0

package/index.cjs

@@ -0,0 +1,2515 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/migrations/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  INTERNAL_TABLES: () => INTERNAL_TABLES,
+  MIGRATION_TRACKING_TABLE: () => MIGRATION_TRACKING_TABLE,
+  areTypesCompatible: () => areTypesCompatible,
+  buildCloneDbFromAdapter: () => buildCloneDbFromAdapter,
+  buildContextFromAdapter: () => buildContextFromAdapter,
+  buildIntrospector: () => buildIntrospector,
+  buildPushDbFromAdapter: () => buildPushDbFromAdapter,
+  buildTrackerFromAdapter: () => buildTrackerFromAdapter,
+  cloneTestApply: () => cloneTestApply,
+  collectionToTableSnapshot: () => collectionToTableSnapshot,
+  collectionsToSchema: () => collectionsToSchema,
+  computeSchemaChecksum: () => computeSchemaChecksum,
+  createDataHelpers: () => createDataHelpers,
+  createSchemaSnapshot: () => createSchemaSnapshot,
+  deserializeSnapshot: () => deserializeSnapshot,
+  detectDangers: () => detectDangers,
+  diffSchemas: () => diffSchemas,
+  ensureTrackingTable: () => ensureTrackingTable,
+  fieldToColumnType: () => fieldToColumnType,
+  fieldToPostgresType: () => fieldToPostgresType,
+  fieldToSqliteType: () => fieldToSqliteType,
+  generateMigrationFileContent: () => generateMigrationFileContent,
+  generateMigrationName: () => generateMigrationName,
+  getAppliedMigrations: () => getAppliedMigrations,
+  getLatestBatchNumber: () => getLatestBatchNumber,
+  getMigrationStatus: () => getMigrationStatus,
+  getMigrationsByBatch: () => getMigrationsByBatch,
+  getNextBatchNumber: () => getNextBatchNumber,
+  getSnapshotPath: () => getSnapshotPath,
+  introspectPostgres: () => introspectPostgres,
+  introspectSqlite: () => introspectSqlite,
+  isMigrationApplied: () => isMigrationApplied,
+  loadMigrationsFromDisk: () => loadMigrationsFromDisk,
+  normalizeColumnType: () => normalizeColumnType,
+  operationToReverseSql: () => operationToReverseSql,
+  operationToSql: () => operationToSql,
+  operationsToDownSql: () => operationsToDownSql,
+  operationsToUpSql: () => operationsToUpSql,
+  parseMigrationArgs: () => parseMigrationArgs,
+  readSnapshot: () => readSnapshot,
+  recordMigration: () => recordMigration,
+  removeMigrationRecord: () => removeMigrationRecord,
+  resolveDialect: () => resolveDialect,
+  rollbackBatch: () => rollbackBatch,
+  runMigrations: () => runMigrations,
+  runPush: () => runPush,
+  serializeSnapshot: () => serializeSnapshot,
+  writeSnapshot: () => writeSnapshot
+});
+module.exports = __toCommonJS(src_exports);
+
+// libs/migrations/src/lib/schema/schema-snapshot.ts
+var import_node_crypto = require("node:crypto");
+var INTERNAL_TABLES = /* @__PURE__ */ new Set(["_momentum_migrations", "_momentum_seeds", "_globals"]);
+function computeSchemaChecksum(tables) {
+  const normalized = tables.map((t) => ({
+    name: t.name,
+    columns: [...t.columns].sort((a, b) => a.name.localeCompare(b.name)),
+    foreignKeys: [...t.foreignKeys].sort(
+      (a, b) => a.constraintName.localeCompare(b.constraintName)
+    ),
+    indexes: [...t.indexes].sort((a, b) => a.name.localeCompare(b.name))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const json2 = JSON.stringify(normalized);
+  return (0, import_node_crypto.createHash)("sha256").update(json2).digest("hex");
+}
+function createSchemaSnapshot(dialect, tables) {
+  return {
+    dialect,
+    tables,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checksum: computeSchemaChecksum(tables)
+  };
+}
+function serializeSnapshot(snapshot) {
+  return JSON.stringify(snapshot, null, "	");
+}
+function deserializeSnapshot(json2) {
+  const parsed = JSON.parse(json2);
+  if (!isSchemaSnapshot(parsed)) {
+    throw new Error("Invalid schema snapshot JSON");
+  }
+  return parsed;
+}
+function isSchemaSnapshot(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return (obj["dialect"] === "postgresql" || obj["dialect"] === "sqlite") && Array.isArray(obj["tables"]) && typeof obj["capturedAt"] === "string" && typeof obj["checksum"] === "string";
+}
+
+// libs/migrations/src/lib/schema/column-type-map.ts
+function fieldToPostgresType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "password":
+    case "radio":
+    case "point":
+      return "TEXT";
+    case "email":
+    case "slug":
+    case "select":
+      return "VARCHAR(255)";
+    case "number":
+      return "NUMERIC";
+    case "checkbox":
+      return "BOOLEAN";
+    case "date":
+      return "TIMESTAMPTZ";
+    case "relationship":
+    case "upload":
+      return "VARCHAR(36)";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "JSONB";
+    case "tabs":
+    case "collapsible":
+    case "row":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function fieldToSqliteType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "email":
+    case "slug":
+    case "select":
+    case "password":
+    case "radio":
+    case "point":
+      return "TEXT";
+    case "number":
+      return "REAL";
+    case "checkbox":
+      return "INTEGER";
+    case "date":
+    case "relationship":
+    case "upload":
+      return "TEXT";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function fieldToColumnType(field, dialect) {
+  if (dialect === "postgresql")
+    return fieldToPostgresType(field);
+  return fieldToSqliteType(field);
+}
+function normalizeColumnType(rawType, dialect) {
+  const upper = rawType.toUpperCase().trim();
+  if (dialect === "postgresql") {
+    return normalizePgType(upper);
+  }
+  return normalizeSqliteType(upper);
+}
+function normalizePgType(type) {
+  const charVaryingMatch = type.match(/^CHARACTER VARYING\((\d+)\)$/);
+  if (charVaryingMatch)
+    return `VARCHAR(${charVaryingMatch[1]})`;
+  if (type === "CHARACTER VARYING")
+    return "VARCHAR(255)";
+  if (type === "TIMESTAMP WITH TIME ZONE")
+    return "TIMESTAMPTZ";
+  if (type === "TIMESTAMP WITHOUT TIME ZONE")
+    return "TIMESTAMP";
+  if (type === "BOOLEAN")
+    return "BOOLEAN";
+  if (type === "NUMERIC")
+    return "NUMERIC";
+  if (type === "TEXT")
+    return "TEXT";
+  if (type === "JSONB")
+    return "JSONB";
+  if (type === "JSON")
+    return "JSON";
+  if (type === "INTEGER")
+    return "INTEGER";
+  if (type === "BIGINT")
+    return "BIGINT";
+  if (type === "REAL")
+    return "REAL";
+  if (type === "DOUBLE PRECISION")
+    return "DOUBLE PRECISION";
+  return type;
+}
+function normalizeSqliteType(type) {
+  if (type === "INT" || type === "INTEGER")
+    return "INTEGER";
+  if (type === "REAL" || type === "FLOAT" || type === "DOUBLE")
+    return "REAL";
+  return type;
+}
+function areTypesCompatible(typeA, typeB, dialect) {
+  const normA = normalizeColumnType(typeA, dialect);
+  const normB = normalizeColumnType(typeB, dialect);
+  return normA === normB;
+}
+
+// libs/migrations/src/lib/schema/introspect-postgres.ts
+async function introspectPostgres(queryFn, schema = "public") {
+  const [columnRows, fkRows, indexRows, pkRows] = await Promise.all([
+    queryFn(
+      `SELECT table_name, column_name, data_type, character_maximum_length, is_nullable, column_default
+			 FROM information_schema.columns
+			 WHERE table_schema = $1
+			 ORDER BY table_name, ordinal_position`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT
+				tc.table_name,
+				tc.constraint_name,
+				kcu.column_name,
+				ccu.table_name AS foreign_table_name,
+				ccu.column_name AS foreign_column_name,
+				rc.delete_rule
+			 FROM information_schema.table_constraints tc
+			 JOIN information_schema.key_column_usage kcu
+				ON tc.constraint_name = kcu.constraint_name
+				AND tc.table_schema = kcu.table_schema
+			 JOIN information_schema.constraint_column_usage ccu
+				ON ccu.constraint_name = tc.constraint_name
+				AND ccu.table_schema = tc.table_schema
+			 JOIN information_schema.referential_constraints rc
+				ON rc.constraint_name = tc.constraint_name
+				AND rc.constraint_schema = tc.constraint_schema
+			 WHERE tc.constraint_type = 'FOREIGN KEY'
+				AND tc.table_schema = $1
+			 ORDER BY tc.table_name, tc.constraint_name`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT tablename, indexname, indexdef
+			 FROM pg_indexes
+			 WHERE schemaname = $1
+			 ORDER BY tablename, indexname`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT tc.table_name, kcu.column_name
+			 FROM information_schema.table_constraints tc
+			 JOIN information_schema.key_column_usage kcu
+				ON tc.constraint_name = kcu.constraint_name
+				AND tc.table_schema = kcu.table_schema
+			 WHERE tc.constraint_type = 'PRIMARY KEY'
+				AND tc.table_schema = $1`,
+      [schema]
+    )
+  ]);
+  const pkLookup = /* @__PURE__ */ new Map();
+  for (const row2 of pkRows) {
+    const tableName = row2.table_name;
+    if (!pkLookup.has(tableName)) {
+      pkLookup.set(tableName, /* @__PURE__ */ new Set());
+    }
+    pkLookup.get(tableName).add(row2.column_name);
+  }
+  const tableColumnsMap = /* @__PURE__ */ new Map();
+  for (const row2 of columnRows) {
+    const tableName = row2.table_name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (!tableColumnsMap.has(tableName)) {
+      tableColumnsMap.set(tableName, []);
+    }
+    const rawType = buildPgColumnType(row2);
+    const pkSet = pkLookup.get(tableName);
+    tableColumnsMap.get(tableName).push({
+      name: row2.column_name,
+      type: normalizeColumnType(rawType, "postgresql"),
+      nullable: row2.is_nullable === "YES",
+      defaultValue: row2.column_default,
+      isPrimaryKey: pkSet?.has(row2.column_name) ?? false
+    });
+  }
+  const tableFkMap = /* @__PURE__ */ new Map();
+  for (const row2 of fkRows) {
+    const tableName = row2.table_name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (!tableFkMap.has(tableName)) {
+      tableFkMap.set(tableName, []);
+    }
+    tableFkMap.get(tableName).push({
+      constraintName: row2.constraint_name,
+      column: row2.column_name,
+      referencedTable: row2.foreign_table_name,
+      referencedColumn: row2.foreign_column_name,
+      onDelete: row2.delete_rule
+    });
+  }
+  const fkConstraintNames = new Set(fkRows.map((r) => r.constraint_name));
+  const tableIndexMap = /* @__PURE__ */ new Map();
+  for (const row2 of indexRows) {
+    const tableName = row2.tablename;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (row2.indexdef.includes("PRIMARY KEY"))
+      continue;
+    if (fkConstraintNames.has(row2.indexname))
+      continue;
+    if (row2.indexname.endsWith("_pkey"))
+      continue;
+    if (!tableIndexMap.has(tableName)) {
+      tableIndexMap.set(tableName, []);
+    }
+    const columns = extractIndexColumns(row2.indexdef);
+    const unique = row2.indexdef.toUpperCase().includes("UNIQUE");
+    tableIndexMap.get(tableName).push({
+      name: row2.indexname,
+      columns,
+      unique
+    });
+  }
+  const tables = [];
+  for (const [tableName, columns] of tableColumnsMap) {
+    tables.push({
+      name: tableName,
+      columns,
+      foreignKeys: tableFkMap.get(tableName) ?? [],
+      indexes: tableIndexMap.get(tableName) ?? []
+    });
+  }
+  return createSchemaSnapshot("postgresql", tables);
+}
+function buildPgColumnType(row2) {
+  const dataType = row2.data_type.toUpperCase();
+  if (dataType === "CHARACTER VARYING") {
+    const len = row2.character_maximum_length ?? 255;
+    return `VARCHAR(${len})`;
+  }
+  if (dataType === "CHARACTER") {
+    const len = row2.character_maximum_length ?? 1;
+    return `CHAR(${len})`;
+  }
+  return dataType;
+}
+function extractIndexColumns(indexDef) {
+  const match = indexDef.match(/\(([^)]+)\)\s*$/);
+  if (!match)
+    return [];
+  return match[1].split(",").map((col) => col.trim().replace(/^"/, "").replace(/"$/, "")).filter((col) => col.length > 0);
+}
+
+// libs/migrations/src/lib/schema/introspect-sqlite.ts
+async function introspectSqlite(queryFn) {
+  const masterRows = await queryFn(
+    `SELECT name, type, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+  );
+  const tables = [];
+  for (const masterRow of masterRows) {
+    const tableName = masterRow.name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    const columnRows = await queryFn(
+      `PRAGMA table_info("${tableName}")`
+    );
+    const columns = columnRows.map((row2) => ({
+      name: row2.name,
+      type: normalizeColumnType(row2.type || "TEXT", "sqlite"),
+      nullable: row2.notnull === 0,
+      defaultValue: row2.dflt_value,
+      isPrimaryKey: row2.pk > 0
+    }));
+    const fkRows = await queryFn(
+      `PRAGMA foreign_key_list("${tableName}")`
+    );
+    const foreignKeys = fkRows.map((row2) => ({
+      constraintName: `fk_${tableName}_${row2.from}`,
+      column: row2.from,
+      referencedTable: row2.table,
+      referencedColumn: row2.to,
+      onDelete: row2.on_delete
+    }));
+    const indexListRows = await queryFn(
+      `PRAGMA index_list("${tableName}")`
+    );
+    const indexes = [];
+    for (const idxRow of indexListRows) {
+      if (idxRow.origin === "pk")
+        continue;
+      const indexInfoRows = await queryFn(
+        `PRAGMA index_info("${idxRow.name}")`
+      );
+      const indexColumns = indexInfoRows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name).filter((n) => n.length > 0);
+      if (indexColumns.length > 0) {
+        indexes.push({
+          name: idxRow.name,
+          columns: indexColumns,
+          unique: idxRow.unique === 1
+        });
+      }
+    }
+    tables.push({
+      name: tableName,
+      columns,
+      foreignKeys,
+      indexes
+    });
+  }
+  return createSchemaSnapshot("sqlite", tables);
+}
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+function getSoftDeleteField(config) {
+  if (!config.softDelete)
+    return null;
+  if (config.softDelete === true)
+    return "deletedAt";
+  const sdConfig = config.softDelete;
+  return sdConfig.field ?? "deletedAt";
+}
+
+// libs/core/src/lib/fields/field.types.ts
+function isNamedTab(tab) {
+  return typeof tab.name === "string" && tab.name.length > 0;
+}
+function flattenDataFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        if (isNamedTab(tab)) {
+          const syntheticGroup = {
+            name: tab.name,
+            type: "group",
+            label: tab.label,
+            description: tab.description,
+            fields: tab.fields
+          };
+          result.push(syntheticGroup);
+        } else {
+          result.push(...flattenDataFields(tab.fields));
+        }
+      }
+    } else if (field.type === "collapsible" || field.type === "row") {
+      result.push(...flattenDataFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/migrations/src/lib/schema/collections-to-schema.ts
+function mapOnDelete(onDelete, required) {
+  const effective = required && (!onDelete || onDelete === "set-null") ? "restrict" : onDelete;
+  switch (effective) {
+    case "restrict":
+      return "RESTRICT";
+    case "cascade":
+      return "CASCADE";
+    default:
+      return "SET NULL";
+  }
+}
+function getTableName(collection) {
+  return collection.dbName ?? collection.slug;
+}
+function hasVersionDrafts(collection) {
+  const versions = collection.versions;
+  if (!versions)
+    return false;
+  if (typeof versions === "boolean")
+    return false;
+  return !!versions.drafts;
+}
+function isCollectionConfig(value) {
+  return typeof value === "object" && value !== null && "slug" in value && "fields" in value;
+}
+function resolveCollectionRef(ref) {
+  try {
+    const resolved = ref();
+    if (isCollectionConfig(resolved)) {
+      return resolved;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function buildAutoColumns(collection, dialect) {
+  const columns = [];
+  columns.push({
+    name: "id",
+    type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+    nullable: false,
+    defaultValue: null,
+    isPrimaryKey: true
+  });
+  const timestamps = collection.timestamps;
+  const addCreatedAt = timestamps !== false && (timestamps === true || timestamps === void 0 || timestamps.createdAt !== false);
+  const addUpdatedAt = timestamps !== false && (timestamps === true || timestamps === void 0 || timestamps.updatedAt !== false);
+  if (addCreatedAt) {
+    columns.push({
+      name: "createdAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  if (addUpdatedAt) {
+    columns.push({
+      name: "updatedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  if (hasVersionDrafts(collection)) {
+    columns.push({
+      name: "_status",
+      type: dialect === "postgresql" ? "VARCHAR(20)" : "TEXT",
+      nullable: false,
+      defaultValue: "'draft'",
+      isPrimaryKey: false
+    });
+  }
+  const softDeleteCol = getSoftDeleteField(collection);
+  if (softDeleteCol) {
+    columns.push({
+      name: softDeleteCol,
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: true,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  return columns;
+}
+function fieldToColumn(field, dialect) {
+  return {
+    name: field.name,
+    type: fieldToColumnType(field, dialect),
+    nullable: !field.required,
+    defaultValue: null,
+    isPrimaryKey: false
+  };
+}
+function buildForeignKeys(tableName, fields) {
+  const foreignKeys = [];
+  for (const field of fields) {
+    if (field.type !== "relationship")
+      continue;
+    if (field.hasMany)
+      continue;
+    if (field.relationTo && field.relationTo.length > 0)
+      continue;
+    const target = resolveCollectionRef(field.collection);
+    if (!target)
+      continue;
+    const targetTable = getTableName(target);
+    const onDelete = mapOnDelete(field.onDelete, !!field.required);
+    foreignKeys.push({
+      constraintName: `fk_${tableName}_${field.name}`,
+      column: field.name,
+      referencedTable: targetTable,
+      referencedColumn: "id",
+      onDelete
+    });
+  }
+  return foreignKeys;
+}
+function buildIndexes(tableName, collection) {
+  const indexes = [];
+  const sdField = getSoftDeleteField(collection);
+  if (sdField) {
+    indexes.push({
+      name: `idx_${tableName}_${sdField}`,
+      columns: [sdField],
+      unique: false
+    });
+  }
+  if (collection.indexes) {
+    for (const idx of collection.indexes) {
+      indexes.push({
+        name: idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`,
+        columns: [...idx.columns],
+        unique: !!idx.unique
+      });
+    }
+  }
+  return indexes;
+}
+function buildVersionTable(collection, dialect) {
+  if (!collection.versions)
+    return null;
+  const baseTable = getTableName(collection);
+  const tableName = `${baseTable}_versions`;
+  const columns = [
+    {
+      name: "id",
+      type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: true
+    },
+    {
+      name: "parent",
+      type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "version",
+      type: "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "_status",
+      type: dialect === "postgresql" ? "VARCHAR(20)" : "TEXT",
+      nullable: false,
+      defaultValue: "'draft'",
+      isPrimaryKey: false
+    },
+    {
+      name: "autosave",
+      type: dialect === "postgresql" ? "BOOLEAN" : "INTEGER",
+      nullable: false,
+      defaultValue: dialect === "postgresql" ? "false" : "0",
+      isPrimaryKey: false
+    },
+    {
+      name: "publishedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: true,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "createdAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "updatedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    }
+  ];
+  const foreignKeys = [
+    {
+      constraintName: `fk_${tableName}_parent`,
+      column: "parent",
+      referencedTable: baseTable,
+      referencedColumn: "id",
+      onDelete: "CASCADE"
+    }
+  ];
+  const indexes = [
+    { name: `idx_${tableName}_parent`, columns: ["parent"], unique: false },
+    { name: `idx_${tableName}_status`, columns: ["_status"], unique: false },
+    { name: `idx_${tableName}_createdAt`, columns: ["createdAt"], unique: false }
+  ];
+  return { name: tableName, columns, foreignKeys, indexes };
+}
+function collectionToTableSnapshot(collection, dialect) {
+  const tableName = getTableName(collection);
+  const dataFields = flattenDataFields(collection.fields);
+  const columns = [
+    ...buildAutoColumns(collection, dialect),
+    ...dataFields.map((f) => fieldToColumn(f, dialect))
+  ];
+  const foreignKeys = buildForeignKeys(tableName, dataFields);
+  const indexes = buildIndexes(tableName, collection);
+  return { name: tableName, columns, foreignKeys, indexes };
+}
+function collectionsToSchema(collections, dialect) {
+  const tables = [];
+  for (const collection of collections) {
+    tables.push(collectionToTableSnapshot(collection, dialect));
+    const versionTable = buildVersionTable(collection, dialect);
+    if (versionTable) {
+      tables.push(versionTable);
+    }
+  }
+  return createSchemaSnapshot(dialect, tables);
+}
+
+// libs/migrations/src/lib/schema/schema-diff.ts
+var DEFAULT_DIFF_OPTIONS = {
+  detectRenames: true,
+  renameSimilarityThreshold: 0.6
+};
+function diffSchemas(desired, actual, dialect, options) {
+  const opts = { ...DEFAULT_DIFF_OPTIONS, ...options };
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const t of desired.tables)
+    desiredMap.set(t.name, t);
+  for (const t of actual.tables)
+    actualMap.set(t.name, t);
+  for (const [name, desiredTable] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "createTable",
+        table: name,
+        columns: desiredTable.columns.map((c) => ({
+          name: c.name,
+          type: c.type,
+          nullable: c.nullable,
+          defaultValue: c.defaultValue ?? void 0,
+          primaryKey: c.isPrimaryKey || void 0
+        }))
+      });
+      summary.push(`Create table "${name}"`);
+      for (const fk of desiredTable.foreignKeys) {
+        operations.push({
+          type: "addForeignKey",
+          table: name,
+          constraintName: fk.constraintName,
+          column: fk.column,
+          referencedTable: fk.referencedTable,
+          referencedColumn: fk.referencedColumn,
+          onDelete: fk.onDelete
+        });
+      }
+      for (const idx of desiredTable.indexes) {
+        operations.push({
+          type: "createIndex",
+          table: name,
+          indexName: idx.name,
+          columns: idx.columns,
+          unique: idx.unique
+        });
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({ type: "dropTable", table: name });
+      summary.push(`Drop table "${name}"`);
+    }
+  }
+  for (const [name, desiredTable] of desiredMap) {
+    const actualTable = actualMap.get(name);
+    if (!actualTable)
+      continue;
+    const tableOps = diffTable(desiredTable, actualTable, dialect, opts);
+    operations.push(...tableOps.operations);
+    summary.push(...tableOps.summary);
+  }
+  return {
+    hasChanges: operations.length > 0,
+    operations,
+    summary
+  };
+}
+function diffTable(desired, actual, dialect, opts) {
+  const operations = [];
+  const summary = [];
+  const tableName = desired.name;
+  const colOps = diffColumns(tableName, desired.columns, actual.columns, dialect, opts);
+  operations.push(...colOps.operations);
+  summary.push(...colOps.summary);
+  const fkOps = diffForeignKeys(tableName, desired.foreignKeys, actual.foreignKeys);
+  operations.push(...fkOps.operations);
+  summary.push(...fkOps.summary);
+  const idxOps = diffIndexes(tableName, desired.indexes, actual.indexes);
+  operations.push(...idxOps.operations);
+  summary.push(...idxOps.summary);
+  return { operations, summary };
+}
+function diffColumns(tableName, desiredColumns, actualColumns, dialect, opts) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const c of desiredColumns)
+    desiredMap.set(c.name, c);
+  for (const c of actualColumns)
+    actualMap.set(c.name, c);
+  const renamedFrom = /* @__PURE__ */ new Set();
+  const renamedTo = /* @__PURE__ */ new Set();
+  if (opts.detectRenames) {
+    const missingInActual = [...desiredMap.keys()].filter((k) => !actualMap.has(k));
+    const extraInActual = [...actualMap.keys()].filter((k) => !desiredMap.has(k));
+    for (const newName of missingInActual) {
+      const desiredCol = desiredMap.get(newName);
+      for (const oldName of extraInActual) {
+        if (renamedFrom.has(oldName))
+          continue;
+        const actualCol = actualMap.get(oldName);
+        if (areTypesCompatible(desiredCol.type, actualCol.type, dialect)) {
+          operations.push({
+            type: "renameColumn",
+            table: tableName,
+            from: oldName,
+            to: newName
+          });
+          summary.push(
+            `Rename column "${tableName}"."${oldName}" \u2192 "${newName}"`
+          );
+          renamedFrom.add(oldName);
+          renamedTo.add(newName);
+          break;
+        }
+      }
+    }
+  }
+  for (const [name, desiredCol] of desiredMap) {
+    if (actualMap.has(name) || renamedTo.has(name))
+      continue;
+    operations.push({
+      type: "addColumn",
+      table: tableName,
+      column: name,
+      columnType: desiredCol.type,
+      nullable: desiredCol.nullable,
+      defaultValue: desiredCol.defaultValue ?? void 0
+    });
+    summary.push(`Add column "${tableName}"."${name}" (${desiredCol.type})`);
+  }
+  for (const [name, actualCol] of actualMap) {
+    if (desiredMap.has(name) || renamedFrom.has(name))
+      continue;
+    operations.push({
+      type: "dropColumn",
+      table: tableName,
+      column: name,
+      previousType: actualCol.type,
+      previousNullable: actualCol.nullable
+    });
+    summary.push(`Drop column "${tableName}"."${name}"`);
+  }
+  for (const [name, desiredCol] of desiredMap) {
+    const actualCol = actualMap.get(name);
+    if (!actualCol)
+      continue;
+    if (!areTypesCompatible(desiredCol.type, actualCol.type, dialect)) {
+      operations.push({
+        type: "alterColumnType",
+        table: tableName,
+        column: name,
+        fromType: normalizeColumnType(actualCol.type, dialect),
+        toType: normalizeColumnType(desiredCol.type, dialect)
+      });
+      summary.push(
+        `Change type "${tableName}"."${name}": ${actualCol.type} \u2192 ${desiredCol.type}`
+      );
+    }
+    if (desiredCol.nullable !== actualCol.nullable) {
+      operations.push({
+        type: "alterColumnNullable",
+        table: tableName,
+        column: name,
+        nullable: desiredCol.nullable
+      });
+      summary.push(
+        `Change nullable "${tableName}"."${name}": ${actualCol.nullable} \u2192 ${desiredCol.nullable}`
+      );
+    }
+    if (normalizeDefault(desiredCol.defaultValue) !== normalizeDefault(actualCol.defaultValue)) {
+      operations.push({
+        type: "alterColumnDefault",
+        table: tableName,
+        column: name,
+        defaultValue: desiredCol.defaultValue,
+        previousDefault: actualCol.defaultValue
+      });
+      summary.push(
+        `Change default "${tableName}"."${name}": ${actualCol.defaultValue ?? "NULL"} \u2192 ${desiredCol.defaultValue ?? "NULL"}`
+      );
+    }
+  }
+  return { operations, summary };
+}
+function normalizeDefault(value) {
+  if (value === null || value === void 0 || value === "")
+    return null;
+  return value;
+}
+function diffForeignKeys(tableName, desiredFks, actualFks) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const fk of desiredFks)
+    desiredMap.set(fk.constraintName, fk);
+  for (const fk of actualFks)
+    actualMap.set(fk.constraintName, fk);
+  for (const [name, fk] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "addForeignKey",
+        table: tableName,
+        constraintName: fk.constraintName,
+        column: fk.column,
+        referencedTable: fk.referencedTable,
+        referencedColumn: fk.referencedColumn,
+        onDelete: fk.onDelete
+      });
+      summary.push(`Add foreign key "${name}" on "${tableName}"`);
+    } else {
+      const actualFk = actualMap.get(name);
+      if (fk.column !== actualFk.column || fk.referencedTable !== actualFk.referencedTable || fk.referencedColumn !== actualFk.referencedColumn || fk.onDelete !== actualFk.onDelete) {
+        operations.push({
+          type: "dropForeignKey",
+          table: tableName,
+          constraintName: name
+        });
+        operations.push({
+          type: "addForeignKey",
+          table: tableName,
+          constraintName: fk.constraintName,
+          column: fk.column,
+          referencedTable: fk.referencedTable,
+          referencedColumn: fk.referencedColumn,
+          onDelete: fk.onDelete
+        });
+        summary.push(`Modify foreign key "${name}" on "${tableName}"`);
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({
+        type: "dropForeignKey",
+        table: tableName,
+        constraintName: name
+      });
+      summary.push(`Drop foreign key "${name}" on "${tableName}"`);
+    }
+  }
+  return { operations, summary };
+}
+function diffIndexes(tableName, desiredIdxs, actualIdxs) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const idx of desiredIdxs)
+    desiredMap.set(idx.name, idx);
+  for (const idx of actualIdxs)
+    actualMap.set(idx.name, idx);
+  for (const [name, idx] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "createIndex",
+        table: tableName,
+        indexName: idx.name,
+        columns: idx.columns,
+        unique: idx.unique
+      });
+      summary.push(`Create index "${name}" on "${tableName}"`);
+    } else {
+      const actualIdx = actualMap.get(name);
+      if (idx.unique !== actualIdx.unique || JSON.stringify(idx.columns) !== JSON.stringify(actualIdx.columns)) {
+        operations.push({
+          type: "dropIndex",
+          table: tableName,
+          indexName: name
+        });
+        operations.push({
+          type: "createIndex",
+          table: tableName,
+          indexName: idx.name,
+          columns: idx.columns,
+          unique: idx.unique
+        });
+        summary.push(`Modify index "${name}" on "${tableName}"`);
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({
+        type: "dropIndex",
+        table: tableName,
+        indexName: name
+      });
+      summary.push(`Drop index "${name}" on "${tableName}"`);
+    }
+  }
+  return { operations, summary };
+}
+
+// libs/migrations/src/lib/generator/sql-generator.ts
+function operationToSql(op, dialect) {
+  switch (op.type) {
+    case "createTable":
+      return generateCreateTable(op, dialect);
+    case "dropTable":
+      return `DROP TABLE IF EXISTS "${op.table}"`;
+    case "renameTable":
+      return `ALTER TABLE "${op.from}" RENAME TO "${op.to}"`;
+    case "addColumn":
+      return generateAddColumn(op, dialect);
+    case "dropColumn":
+      return generateDropColumn(op, dialect);
+    case "alterColumnType":
+      return generateAlterColumnType(op, dialect);
+    case "alterColumnNullable":
+      return generateAlterColumnNullable(op, dialect);
+    case "alterColumnDefault":
+      return generateAlterColumnDefault(op, dialect);
+    case "renameColumn":
+      return `ALTER TABLE "${op.table}" RENAME COLUMN "${op.from}" TO "${op.to}"`;
+    case "addForeignKey":
+      return generateAddForeignKey(op, dialect);
+    case "dropForeignKey":
+      return generateDropForeignKey(op, dialect);
+    case "createIndex":
+      return generateCreateIndex(op);
+    case "dropIndex":
+      return `DROP INDEX IF EXISTS "${op.indexName}"`;
+    case "rawSql":
+      return op.upSql;
+  }
+}
+function operationToReverseSql(op, dialect) {
+  switch (op.type) {
+    case "createTable":
+      return `DROP TABLE IF EXISTS "${op.table}"`;
+    case "dropTable":
+      return null;
+    case "renameTable":
+      return `ALTER TABLE "${op.to}" RENAME TO "${op.from}"`;
+    case "addColumn":
+      return `ALTER TABLE "${op.table}" DROP COLUMN "${op.column}"`;
+    case "dropColumn":
+      if (op.previousType) {
+        const nullable = op.previousNullable !== false ? "" : " NOT NULL";
+        return `ALTER TABLE "${op.table}" ADD COLUMN "${op.column}" ${op.previousType}${nullable}`;
+      }
+      return null;
+    case "alterColumnType":
+      return generateAlterColumnType(
+        { ...op, fromType: op.toType, toType: op.fromType },
+        dialect
+      );
+    case "alterColumnNullable":
+      return generateAlterColumnNullable(
+        { ...op, nullable: !op.nullable },
+        dialect
+      );
+    case "alterColumnDefault":
+      return generateAlterColumnDefault(
+        {
+          ...op,
+          defaultValue: op.previousDefault,
+          previousDefault: op.defaultValue
+        },
+        dialect
+      );
+    case "renameColumn":
+      return `ALTER TABLE "${op.table}" RENAME COLUMN "${op.to}" TO "${op.from}"`;
+    case "addForeignKey":
+      return generateDropForeignKey(
+        { type: "dropForeignKey", table: op.table, constraintName: op.constraintName },
+        dialect
+      );
+    case "dropForeignKey":
+      return null;
+    case "createIndex":
+      return `DROP INDEX IF EXISTS "${op.indexName}"`;
+    case "dropIndex":
+      return null;
+    case "rawSql":
+      return op.downSql;
+  }
+}
+function operationsToUpSql(operations, dialect) {
+  return operations.map((op) => operationToSql(op, dialect));
+}
+function operationsToDownSql(operations, dialect) {
+  return [...operations].reverse().map((op) => operationToReverseSql(op, dialect)).filter((sql) => sql !== null);
+}
+function generateCreateTable(op, _dialect) {
+  const columnDefs = op.columns.map((c) => {
+    let def = `"${c.name}" ${c.type}`;
+    if (c.primaryKey)
+      def += " PRIMARY KEY";
+    if (!c.nullable)
+      def += " NOT NULL";
+    if (c.defaultValue)
+      def += ` DEFAULT ${c.defaultValue}`;
+    return def;
+  });
+  return `CREATE TABLE "${op.table}" (
+  ${columnDefs.join(",\n  ")}
+)`;
+}
+function generateAddColumn(op, _dialect) {
+  let sql = `ALTER TABLE "${op.table}" ADD COLUMN "${op.column}" ${op.columnType}`;
+  if (!op.nullable)
+    sql += " NOT NULL";
+  if (op.defaultValue)
+    sql += ` DEFAULT ${op.defaultValue}`;
+  return sql;
+}
+function generateDropColumn(op, _dialect) {
+  return `ALTER TABLE "${op.table}" DROP COLUMN "${op.column}"`;
+}
+function generateAlterColumnType(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter column type for "${op.table}"."${op.column}" (${op.fromType} \u2192 ${op.toType}). Requires table rebuild.`;
+  }
+  const using = op.castExpression ? ` USING ${op.castExpression}` : ` USING "${op.column}"::${op.toType}`;
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" TYPE ${op.toType}${using}`;
+}
+function generateAlterColumnNullable(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter nullable for "${op.table}"."${op.column}". Requires table rebuild.`;
+  }
+  if (op.nullable) {
+    return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" DROP NOT NULL`;
+  }
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" SET NOT NULL`;
+}
+function generateAlterColumnDefault(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter default for "${op.table}"."${op.column}". Requires table rebuild.`;
+  }
+  if (op.defaultValue === null) {
+    return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" DROP DEFAULT`;
+  }
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" SET DEFAULT ${op.defaultValue}`;
+}
+function generateAddForeignKey(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot add FK "${op.constraintName}" after table creation. Requires table rebuild.`;
+  }
+  return `ALTER TABLE "${op.table}" ADD CONSTRAINT "${op.constraintName}" FOREIGN KEY ("${op.column}") REFERENCES "${op.referencedTable}"("${op.referencedColumn}") ON DELETE ${op.onDelete}`;
+}
+function generateDropForeignKey(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot drop FK "${op.constraintName}" after table creation. Requires table rebuild.`;
+  }
+  return `ALTER TABLE "${op.table}" DROP CONSTRAINT "${op.constraintName}"`;
+}
+function generateCreateIndex(op) {
+  const unique = op.unique ? "UNIQUE " : "";
+  const cols = op.columns.map((c) => `"${c}"`).join(", ");
+  return `CREATE ${unique}INDEX IF NOT EXISTS "${op.indexName}" ON "${op.table}" (${cols})`;
+}
+
+// libs/migrations/src/lib/generator/migration-file-generator.ts
+function generateMigrationName(name, timestamp) {
+  const d = timestamp ?? /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const prefix = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+  return `${prefix}_${name}`;
+}
+function generateMigrationFileContent(diff, options) {
+  const { name, description, dialect } = options;
+  const desc = description ?? (diff.summary.join("; ") || "Auto-generated migration");
+  const upStatements = operationsToUpSql(diff.operations, dialect);
+  const downStatements = operationsToDownSql(diff.operations, dialect);
+  const operationsMeta = serializeOperationsMeta(diff.operations);
+  const lines = [];
+  lines.push("import type { MigrationFile, MigrationContext } from '@momentumcms/migrations';");
+  lines.push("");
+  lines.push("export const meta: MigrationFile['meta'] = {");
+  lines.push(`	name: ${JSON.stringify(name)},`);
+  lines.push(`	description: ${JSON.stringify(desc)},`);
+  lines.push(`	operations: ${operationsMeta},`);
+  lines.push("};");
+  lines.push("");
+  lines.push("export async function up(ctx: MigrationContext): Promise<void> {");
+  for (const sql of upStatements) {
+    if (sql.startsWith("--")) {
+      lines.push(`	// ${sql.slice(3)}`);
+    } else {
+      lines.push(`	await ctx.sql(${JSON.stringify(sql)});`);
+    }
+  }
+  if (upStatements.length === 0) {
+    lines.push("	// No operations");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("export async function down(ctx: MigrationContext): Promise<void> {");
+  for (const sql of downStatements) {
+    if (sql.startsWith("--")) {
+      lines.push(`	// ${sql.slice(3)}`);
+    } else {
+      lines.push(`	await ctx.sql(${JSON.stringify(sql)});`);
+    }
+  }
+  if (downStatements.length === 0) {
+    lines.push("	// Cannot reverse all operations");
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function serializeOperationsMeta(operations) {
+  const simplified = operations.map((op) => {
+    switch (op.type) {
+      case "createTable":
+        return { type: op.type, table: op.table };
+      case "dropTable":
+        return { type: op.type, table: op.table };
+      case "renameTable":
+        return { type: op.type, from: op.from, to: op.to };
+      case "addColumn":
+        return {
+          type: op.type,
+          table: op.table,
+          column: op.column,
+          nullable: op.nullable,
+          defaultValue: op.defaultValue ?? null
+        };
+      case "dropColumn":
+        return { type: op.type, table: op.table, column: op.column };
+      case "alterColumnType":
+        return {
+          type: op.type,
+          table: op.table,
+          column: op.column,
+          fromType: op.fromType,
+          toType: op.toType
+        };
+      case "alterColumnNullable":
+        return { type: op.type, table: op.table, column: op.column, nullable: op.nullable };
+      case "alterColumnDefault":
+        return { type: op.type, table: op.table, column: op.column };
+      case "renameColumn":
+        return { type: op.type, table: op.table, from: op.from, to: op.to };
+      case "addForeignKey":
+        return { type: op.type, table: op.table, constraintName: op.constraintName };
+      case "dropForeignKey":
+        return { type: op.type, table: op.table, constraintName: op.constraintName };
+      case "createIndex":
+        return { type: op.type, table: op.table, indexName: op.indexName };
+      case "dropIndex":
+        return { type: op.type, table: op.table, indexName: op.indexName };
+      case "rawSql":
+        return { type: op.type, description: op.description };
+    }
+  });
+  return JSON.stringify(simplified, null, "	");
+}
+
+// libs/migrations/src/lib/migration.types.ts
+var MIGRATION_TRACKING_TABLE = "_momentum_migrations";
+
+// libs/migrations/src/lib/tracking/migration-tracker.ts
+async function ensureTrackingTable(db, dialect) {
+  if (dialect === "postgresql") {
+    await db.execute(`
+			CREATE TABLE IF NOT EXISTS "${MIGRATION_TRACKING_TABLE}" (
+				"id" VARCHAR(36) PRIMARY KEY,
+				"name" VARCHAR(255) NOT NULL UNIQUE,
+				"batch" INTEGER NOT NULL,
+				"checksum" VARCHAR(64) NOT NULL,
+				"appliedAt" TIMESTAMPTZ NOT NULL,
+				"executionMs" INTEGER NOT NULL
+			)
+		`);
+  } else {
+    await db.execute(`
+			CREATE TABLE IF NOT EXISTS "${MIGRATION_TRACKING_TABLE}" (
+				"id" TEXT PRIMARY KEY,
+				"name" TEXT NOT NULL UNIQUE,
+				"batch" INTEGER NOT NULL,
+				"checksum" TEXT NOT NULL,
+				"appliedAt" TEXT NOT NULL,
+				"executionMs" INTEGER NOT NULL
+			)
+		`);
+  }
+}
+async function getAppliedMigrations(db) {
+  const rows = await db.query(
+    `SELECT * FROM "${MIGRATION_TRACKING_TABLE}" ORDER BY "batch" ASC, "name" ASC`
+  );
+  return rows.map(toTrackingRecord);
+}
+async function getNextBatchNumber(db) {
+  const rows = await db.query(
+    `SELECT MAX("batch") as max_batch FROM "${MIGRATION_TRACKING_TABLE}"`
+  );
+  const maxBatch = rows[0]?.max_batch;
+  return (typeof maxBatch === "number" ? maxBatch : 0) + 1;
+}
+async function recordMigration(db, record, dialect) {
+  const id = generateUUID();
+  const full = { id, ...record };
+  if (dialect === "postgresql") {
+    await db.execute(
+      `INSERT INTO "${MIGRATION_TRACKING_TABLE}" ("id", "name", "batch", "checksum", "appliedAt", "executionMs")
+			 VALUES ($1, $2, $3, $4, $5, $6)`,
+      [full.id, full.name, full.batch, full.checksum, full.appliedAt, full.executionMs]
+    );
+  } else {
+    await db.execute(
+      `INSERT INTO "${MIGRATION_TRACKING_TABLE}" ("id", "name", "batch", "checksum", "appliedAt", "executionMs")
+			 VALUES (?, ?, ?, ?, ?, ?)`,
+      [full.id, full.name, full.batch, full.checksum, full.appliedAt, full.executionMs]
+    );
+  }
+  return full;
+}
+async function removeMigrationRecord(db, name, dialect) {
+  const placeholder = dialect === "postgresql" ? "$1" : "?";
+  const affected = await db.execute(
+    `DELETE FROM "${MIGRATION_TRACKING_TABLE}" WHERE "name" = ${placeholder}`,
+    [name]
+  );
+  return affected > 0;
+}
+async function getMigrationsByBatch(db, batch, dialect) {
+  const placeholder = dialect === "postgresql" ? "$1" : "?";
+  const rows = await db.query(
+    `SELECT * FROM "${MIGRATION_TRACKING_TABLE}" WHERE "batch" = ${placeholder} ORDER BY "name" DESC`,
+    [batch]
+  );
+  return rows.map(toTrackingRecord);
+}
+async function getLatestBatchNumber(db) {
+  const rows = await db.query(
+    `SELECT MAX("batch") as max_batch FROM "${MIGRATION_TRACKING_TABLE}"`
+  );
+  return typeof rows[0]?.max_batch === "number" ? rows[0].max_batch : 0;
+}
+async function isMigrationApplied(db, name, dialect) {
+  const placeholder = dialect === "postgresql" ? "$1" : "?";
+  const rows = await db.query(
+    `SELECT COUNT(*) as cnt FROM "${MIGRATION_TRACKING_TABLE}" WHERE "name" = ${placeholder}`,
+    [name]
+  );
+  return (rows[0]?.cnt ?? 0) > 0;
+}
+function toTrackingRecord(row2) {
+  return {
+    id: String(row2["id"]),
+    name: String(row2["name"]),
+    batch: Number(row2["batch"]),
+    checksum: String(row2["checksum"]),
+    appliedAt: String(row2["appliedAt"]),
+    executionMs: Number(row2["executionMs"])
+  };
+}
+function generateUUID() {
+  const crypto = require("node:crypto");
+  return crypto.randomUUID();
+}
+
+// libs/migrations/src/lib/danger/danger-detector.ts
+function detectDangers(operations, dialect) {
+  const warnings = [];
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    warnings.push(...checkOperation(op, i, operations, dialect));
+  }
+  const severityOrder = { error: 0, warning: 1, info: 2 };
+  warnings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  return {
+    warnings,
+    hasErrors: warnings.some((w) => w.severity === "error"),
+    hasWarnings: warnings.some((w) => w.severity === "warning")
+  };
+}
+function checkOperation(op, index, _allOps, dialect) {
+  const warnings = [];
+  switch (op.type) {
+    case "dropTable":
+      warnings.push({
+        severity: "error",
+        operation: op,
+        operationIndex: index,
+        message: `Dropping table "${op.table}" will permanently delete all data.`,
+        suggestion: 'Consider renaming the table with a deprecation prefix (e.g., "_deprecated_") and scheduling deletion after verifying no data is needed.'
+      });
+      break;
+    case "dropColumn":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Dropping column "${op.table}"."${op.column}" will permanently delete all values in this column.`,
+        suggestion: "Before dropping, verify the column data is either migrated elsewhere or truly unneeded. Consider a backup or data export first."
+      });
+      break;
+    case "alterColumnType":
+      warnings.push(...checkTypeChange(op, index, dialect));
+      break;
+    case "alterColumnNullable":
+      if (!op.nullable) {
+        warnings.push({
+          severity: "warning",
+          operation: op,
+          operationIndex: index,
+          message: `Setting "${op.table}"."${op.column}" to NOT NULL may fail if existing rows contain NULL values.`,
+          suggestion: "First backfill NULL values with a default (e.g., UPDATE table SET column = 'default' WHERE column IS NULL), then add the NOT NULL constraint."
+        });
+      }
+      break;
+    case "addColumn":
+      if (!op.nullable && !op.defaultValue) {
+        warnings.push({
+          severity: "error",
+          operation: op,
+          operationIndex: index,
+          message: `Adding NOT NULL column "${op.table}"."${op.column}" without a default value will fail if the table has existing rows.`,
+          suggestion: "Either add a DEFAULT value, make the column nullable first and backfill, or add the column as nullable, backfill, then alter to NOT NULL."
+        });
+      }
+      break;
+    case "renameColumn":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Renaming "${op.table}"."${op.from}" to "${op.to}" may break application code that references the old name.`,
+        suggestion: "Deploy application code changes to use the new column name before or alongside the migration. Consider a phased approach: add new column, migrate data, update code, then drop old column."
+      });
+      break;
+    case "renameTable":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Renaming table "${op.from}" to "${op.to}" may break application code and queries.`,
+        suggestion: "Update application code to use the new table name before or alongside the migration."
+      });
+      break;
+    case "addForeignKey":
+      if (dialect === "postgresql") {
+        warnings.push({
+          severity: "info",
+          operation: op,
+          operationIndex: index,
+          message: `Adding foreign key "${op.constraintName}" acquires an ACCESS EXCLUSIVE lock on the referenced table.`,
+          suggestion: "On large tables, consider adding the FK constraint with NOT VALID first, then validating separately: ALTER TABLE ... ADD CONSTRAINT ... NOT VALID; ALTER TABLE ... VALIDATE CONSTRAINT ..."
+        });
+      }
+      break;
+    case "createIndex":
+      if (dialect === "postgresql" && !isCreateIndexConcurrent(op)) {
+        warnings.push({
+          severity: "info",
+          operation: op,
+          operationIndex: index,
+          message: `Creating index "${op.indexName}" will lock "${op.table}" for writes during index creation.`,
+          suggestion: "For large tables, consider CREATE INDEX CONCURRENTLY to avoid blocking writes (requires running outside a transaction)."
+        });
+      }
+      break;
+  }
+  return warnings;
+}
+function checkTypeChange(op, index, dialect) {
+  const warnings = [];
+  if (dialect === "sqlite") {
+    warnings.push({
+      severity: "error",
+      operation: op,
+      operationIndex: index,
+      message: `SQLite does not support ALTER COLUMN TYPE. Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} requires a table rebuild.`,
+      suggestion: "Create a new table with the desired schema, copy data, drop old table, and rename new table. Use a raw SQL migration for this."
+    });
+    return warnings;
+  }
+  if (isLossyTypeChange(op.fromType, op.toType)) {
+    warnings.push({
+      severity: "warning",
+      operation: op,
+      operationIndex: index,
+      message: `Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} may cause data loss or cast errors.`,
+      suggestion: "Test the type conversion on a clone database first. Consider adding a USING clause with explicit cast logic."
+    });
+  }
+  if (isTableRewriteType(op.fromType, op.toType)) {
+    warnings.push({
+      severity: "info",
+      operation: op,
+      operationIndex: index,
+      message: `Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} may require a table rewrite on large tables.`,
+      suggestion: "On large tables, this can take significant time and lock the table. Consider running during low-traffic periods or using a phased approach."
+    });
+  }
+  return warnings;
+}
+function isLossyTypeChange(from, to) {
+  const fromUpper = from.toUpperCase();
+  const toUpper = to.toUpperCase();
+  if (isTextType(fromUpper) && isNumericType(toUpper))
+    return true;
+  if (fromUpper === "NUMERIC" && (toUpper === "INTEGER" || toUpper === "SMALLINT"))
+    return true;
+  if (fromUpper === "BIGINT" && (toUpper === "INTEGER" || toUpper === "SMALLINT"))
+    return true;
+  if (fromUpper === "DOUBLE PRECISION" && toUpper === "REAL")
+    return true;
+  if ((fromUpper === "JSONB" || fromUpper === "JSON") && !fromUpper.includes("JSON"))
+    return true;
+  if (fromUpper.includes("TIMESTAMP") && toUpper === "DATE")
+    return true;
+  const fromLength = extractLength(fromUpper);
+  const toLength = extractLength(toUpper);
+  if (fromLength && toLength && toLength < fromLength)
+    return true;
+  return false;
+}
+function isTableRewriteType(from, to) {
+  const fromUpper = from.toUpperCase();
+  const toUpper = to.toUpperCase();
+  if (fromUpper.startsWith("VARCHAR") && toUpper === "TEXT")
+    return false;
+  if (fromUpper === "TEXT" && toUpper.startsWith("VARCHAR"))
+    return true;
+  if (isNumericType(fromUpper) !== isNumericType(toUpper))
+    return true;
+  return false;
+}
+function isTextType(type) {
+  return type === "TEXT" || type.startsWith("VARCHAR") || type.startsWith("CHAR");
+}
+function isNumericType(type) {
+  return ["INTEGER", "BIGINT", "SMALLINT", "NUMERIC", "REAL", "DOUBLE PRECISION", "FLOAT"].includes(
+    type
+  );
+}
+function extractLength(type) {
+  const match = type.match(/\((\d+)\)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function isCreateIndexConcurrent(_op) {
+  return false;
+}
+
+// libs/migrations/src/lib/runner/push-runner.ts
+async function runPush(options) {
+  const { collections, dialect, db, introspect, dryRun, skipDangerDetection, log } = options;
+  const noop = { info: () => {
+  }, warn: () => {
+  } };
+  const logger = log ?? noop;
+  const desired = collectionsToSchema(collections, dialect);
+  const actual = await introspect();
+  const diff = diffSchemas(desired, actual, dialect);
+  if (!diff.hasChanges) {
+    logger.info("Schema is up to date. No changes needed.");
+    return {
+      applied: false,
+      diff,
+      dangers: null,
+      sqlStatements: [],
+      successCount: 0,
+      errors: []
+    };
+  }
+  let dangers = null;
+  if (!skipDangerDetection) {
+    dangers = detectDangers(diff.operations, dialect);
+    if (dangers.hasErrors) {
+      logger.warn(
+        `Found ${dangers.warnings.filter((w) => w.severity === "error").length} dangerous operations. Push blocked.`
+      );
+      return {
+        applied: false,
+        diff,
+        dangers,
+        sqlStatements: [],
+        successCount: 0,
+        errors: []
+      };
+    }
+  }
+  const sqlStatements = operationsToUpSql(diff.operations, dialect);
+  if (dryRun) {
+    logger.info(`Dry run: ${sqlStatements.length} statements would be executed.`);
+    return {
+      applied: false,
+      diff,
+      dangers,
+      sqlStatements,
+      successCount: 0,
+      errors: []
+    };
+  }
+  let successCount = 0;
+  const errors = [];
+  for (const sql of sqlStatements) {
+    if (sql.startsWith("--")) {
+      logger.info(`Skipping: ${sql}`);
+      continue;
+    }
+    try {
+      await db.executeRaw(sql);
+      successCount++;
+      logger.info(`OK: ${sql.slice(0, 80)}${sql.length > 80 ? "..." : ""}`);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      errors.push({ sql, error: errMsg });
+      logger.warn(`FAILED: ${sql.slice(0, 80)} \u2014 ${errMsg}`);
+    }
+  }
+  logger.info(
+    `Push complete: ${successCount} applied, ${errors.length} failed out of ${sqlStatements.length} statements.`
+  );
+  return {
+    applied: successCount > 0,
+    diff,
+    dangers,
+    sqlStatements,
+    successCount,
+    errors
+  };
+}
+
+// libs/migrations/src/lib/runner/migrate-runner.ts
+var import_node_crypto2 = require("node:crypto");
+async function runMigrations(options) {
+  const { migrations, dialect, tracker, buildContext, skipDangerDetection, log } = options;
+  const noop = {
+    info: () => {
+    },
+    warn: () => {
+    }
+  };
+  const logger = log ?? noop;
+  await ensureTrackingTable(tracker, dialect);
+  const applied = await getAppliedMigrations(tracker);
+  const appliedNames = new Set(applied.map((m) => m.name));
+  const pending = migrations.filter((m) => !appliedNames.has(m.name));
+  if (pending.length === 0) {
+    logger.info("No pending migrations.");
+    return {
+      batch: 0,
+      results: [],
+      successCount: 0,
+      failCount: 0,
+      dangers: null
+    };
+  }
+  let dangers = null;
+  if (!skipDangerDetection) {
+    const allOps = pending.flatMap((m) => {
+      const ops = m.file.meta.operations;
+      if (!ops)
+        return [];
+      return ops.filter((op) => typeof op.type === "string").map(toMigrationOperation);
+    });
+    if (allOps.length > 0) {
+      dangers = detectDangers(allOps, dialect);
+      if (dangers.hasErrors) {
+        logger.warn("Dangerous operations detected. Migration blocked.");
+        return {
+          batch: 0,
+          results: [],
+          successCount: 0,
+          failCount: 0,
+          dangers
+        };
+      }
+    }
+  }
+  const batch = await getNextBatchNumber(tracker);
+  logger.info(`Running ${pending.length} migration(s) in batch ${batch}...`);
+  const results = [];
+  const ctx = buildContext();
+  for (const migration of pending) {
+    const start = Date.now();
+    try {
+      await migration.file.up(ctx);
+      const executionMs = Date.now() - start;
+      const checksum = computeMigrationChecksum(migration);
+      await recordMigration(
+        tracker,
+        {
+          name: migration.name,
+          batch,
+          checksum,
+          appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          executionMs
+        },
+        dialect
+      );
+      results.push({ name: migration.name, success: true, executionMs });
+      logger.info(`  OK: ${migration.name} (${executionMs}ms)`);
+    } catch (err) {
+      const executionMs = Date.now() - start;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const errorCode = extractErrorCode(err);
+      results.push({ name: migration.name, success: false, executionMs, error: errMsg, errorCode });
+      logger.warn(`  FAILED: ${migration.name} \u2014 ${errMsg}`);
+      break;
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  logger.info(`Batch ${batch}: ${successCount} applied, ${failCount} failed.`);
+  return { batch, results, successCount, failCount, dangers };
+}
+async function rollbackBatch(options) {
+  const { migrations, dialect, tracker, buildContext, log } = options;
+  const noop = {
+    info: () => {
+    },
+    warn: () => {
+    }
+  };
+  const logger = log ?? noop;
+  await ensureTrackingTable(tracker, dialect);
+  const latestBatch = await getLatestBatchNumber(tracker);
+  if (latestBatch === 0) {
+    logger.info("Nothing to rollback.");
+    return { batch: 0, results: [], successCount: 0, failCount: 0, dangers: null };
+  }
+  const batchMigrations = await getMigrationsByBatch(tracker, latestBatch, dialect);
+  if (batchMigrations.length === 0) {
+    logger.info("No migrations in latest batch.");
+    return { batch: 0, results: [], successCount: 0, failCount: 0, dangers: null };
+  }
+  logger.info(`Rolling back batch ${latestBatch} (${batchMigrations.length} migration(s))...`);
+  const migrationMap = new Map(migrations.map((m) => [m.name, m]));
+  const results = [];
+  const ctx = buildContext();
+  for (const record of batchMigrations) {
+    const migration = migrationMap.get(record.name);
+    if (!migration) {
+      results.push({
+        name: record.name,
+        success: false,
+        executionMs: 0,
+        error: `Migration file "${record.name}" not found`
+      });
+      logger.warn(`  MISSING: ${record.name}`);
+      break;
+    }
+    const start = Date.now();
+    try {
+      await migration.file.down(ctx);
+      const executionMs = Date.now() - start;
+      await removeMigrationRecord(tracker, record.name, dialect);
+      results.push({ name: record.name, success: true, executionMs });
+      logger.info(`  Rolled back: ${record.name} (${executionMs}ms)`);
+    } catch (err) {
+      const executionMs = Date.now() - start;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const errorCode = extractErrorCode(err);
+      results.push({ name: record.name, success: false, executionMs, error: errMsg, errorCode });
+      logger.warn(`  FAILED rollback: ${record.name} \u2014 ${errMsg}`);
+      break;
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  return { batch: latestBatch, results, successCount, failCount, dangers: null };
+}
+async function getMigrationStatus(migrations, tracker, dialect) {
+  await ensureTrackingTable(tracker, dialect);
+  const applied = await getAppliedMigrations(tracker);
+  const appliedMap = new Map(applied.map((m) => [m.name, m]));
+  return migrations.map((m) => {
+    const record = appliedMap.get(m.name);
+    if (record) {
+      return {
+        name: m.name,
+        status: "applied",
+        batch: record.batch,
+        appliedAt: record.appliedAt
+      };
+    }
+    return { name: m.name, status: "pending" };
+  });
+}
+function extractErrorCode(err) {
+  if (err !== null && typeof err === "object" && "code" in err && typeof err.code === "string") {
+    return err.code;
+  }
+  return void 0;
+}
+function toMigrationOperation(op) {
+  return op;
+}
+function computeMigrationChecksum(migration) {
+  const content = JSON.stringify(migration.file.meta) + migration.file.up.toString() + migration.file.down.toString();
+  return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex");
+}
+
+// libs/migrations/src/lib/runner/clone-test-apply.ts
+async function cloneTestApply(options) {
+  const {
+    migrations,
+    dialect,
+    tracker,
+    buildContext,
+    db,
+    buildCloneTracker,
+    buildCloneContext,
+    testOnly,
+    skipDangerDetection,
+    log
+  } = options;
+  const noop = { info: () => {
+  }, warn: () => {
+  } };
+  const logger = log ?? noop;
+  const timestamp = Date.now();
+  const cloneName = `_mig_clone_${timestamp}`;
+  let cloneCleanedUp = false;
+  const result = {
+    phase: "clone",
+    cloneResult: null,
+    applyResult: null,
+    dangers: null,
+    cloneCleanedUp: false,
+    cloneName,
+    suggestions: []
+  };
+  try {
+    logger.info(`Cloning database to "${cloneName}"...`);
+    await db.cloneDatabase(cloneName);
+    logger.info("Clone created successfully.");
+    result.phase = "test";
+    logger.info("Running migrations on clone...");
+    const cloneTracker = buildCloneTracker(cloneName);
+    const cloneContext = buildCloneContext(cloneName);
+    const cloneResult = await runMigrations({
+      migrations,
+      dialect,
+      tracker: cloneTracker,
+      buildContext: () => cloneContext,
+      skipDangerDetection,
+      log: {
+        info: (msg) => logger.info(`[clone] ${msg}`),
+        warn: (msg) => logger.warn(`[clone] ${msg}`)
+      }
+    });
+    result.cloneResult = cloneResult;
+    result.dangers = cloneResult.dangers;
+    if (cloneResult.failCount > 0) {
+      const suggestions = generateFixSuggestions(cloneResult);
+      result.suggestions = suggestions;
+      result.error = `Migration failed on clone: ${cloneResult.results.find((r) => !r.success)?.error}`;
+      logger.warn("Migration failed on clone. Suggestions:");
+      for (const suggestion of suggestions) {
+        logger.warn(`  - ${suggestion}`);
+      }
+      await cleanupClone(db, cloneName, logger);
+      result.cloneCleanedUp = true;
+      cloneCleanedUp = true;
+      return result;
+    }
+    logger.info(`Clone test passed: ${cloneResult.successCount} migration(s) applied.`);
+    await cleanupClone(db, cloneName, logger);
+    result.cloneCleanedUp = true;
+    cloneCleanedUp = true;
+    if (testOnly) {
+      result.phase = "skipped";
+      logger.info("Test-only mode: skipping real database apply.");
+      return result;
+    }
+    result.phase = "apply";
+    logger.info("Applying migrations to real database...");
+    const applyResult = await runMigrations({
+      migrations,
+      dialect,
+      tracker,
+      buildContext,
+      skipDangerDetection: true,
+      // Already validated on clone
+      log: logger
+    });
+    result.applyResult = applyResult;
+    if (applyResult.failCount > 0) {
+      result.error = `Migration failed on real database: ${applyResult.results.find((r) => !r.success)?.error}`;
+      return result;
+    }
+    result.phase = "complete";
+    logger.info(
+      `Pipeline complete: ${applyResult.successCount} migration(s) applied to real database.`
+    );
+    return result;
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    result.error = errMsg;
+    logger.warn(`Pipeline error: ${errMsg}`);
+    if (!cloneCleanedUp) {
+      await cleanupClone(db, cloneName, logger);
+      result.cloneCleanedUp = true;
+    }
+    return result;
+  }
+}
+async function cleanupClone(db, cloneName, logger) {
+  try {
+    await db.dropClone(cloneName);
+    logger.info(`Clone "${cloneName}" cleaned up.`);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Failed to clean up clone "${cloneName}": ${errMsg}`);
+  }
+}
+var SQLSTATE_SUGGESTIONS = {
+  // Class 23 — Integrity Constraint Violation
+  "23502": "NOT NULL constraint violation. Backfill NULL values before adding the constraint: Use ctx.data.backfill(table, column, defaultValue) in a prior migration step.",
+  "23505": "Unique constraint violation. Use ctx.data.dedup() to remove duplicates before adding the unique constraint.",
+  "23503": "Foreign key constraint violation. Ensure referenced data exists before adding the constraint. Consider using ctx.data.backfill() to populate references, or add the FK with NOT VALID first.",
+  // Class 42 — Syntax Error or Access Rule Violation
+  "42P07": "The table already exists. Check if a previous migration already created it, or use IF NOT EXISTS in your DDL.",
+  "42701": "The column already exists. Check if a previous migration already created it, or use IF NOT EXISTS in your DDL.",
+  "42P01": "Referenced table does not exist. Check migration ordering \u2014 the table must be created before it can be referenced.",
+  "42703": "Referenced column does not exist. Check migration ordering \u2014 the column must be created before it can be referenced.",
+  // Class 22 — Data Exception
+  "22P02": "Type conversion error. The data contains values that cannot be converted to the target type. Use ctx.data.transform() to clean up values before altering the column type.",
+  "42804": "Type conversion error. Add an explicit USING clause for the type change, or use ctx.data.transform() to convert values before altering the column type."
+};
+function generateFixSuggestions(result) {
+  const suggestions = [];
+  const failedMigration = result.results.find((r) => !r.success);
+  if (!failedMigration)
+    return suggestions;
+  if (failedMigration.errorCode) {
+    const codeSuggestion = SQLSTATE_SUGGESTIONS[failedMigration.errorCode];
+    if (codeSuggestion) {
+      suggestions.push(codeSuggestion);
+      return suggestions;
+    }
+  }
+  const error = failedMigration.error ?? "";
+  if (error.includes("NOT NULL") && error.includes("contains null")) {
+    suggestions.push(
+      "Backfill NULL values before adding NOT NULL constraint: Use ctx.data.backfill(table, column, defaultValue) in a prior migration step."
+    );
+  }
+  if (error.includes("already exists")) {
+    suggestions.push(
+      "The column or table already exists. Check if a previous migration already created it, or use IF NOT EXISTS in your DDL."
+    );
+  }
+  if (error.includes("violates foreign key")) {
+    suggestions.push(
+      "Foreign key constraint violation. Ensure referenced data exists before adding the constraint. Consider using ctx.data.backfill() to populate references, or add the FK with NOT VALID first."
+    );
+  }
+  if (error.includes("does not exist")) {
+    suggestions.push(
+      "Referenced table or column does not exist. Check migration ordering \u2014 the table/column must be created before it can be referenced."
+    );
+  }
+  if (error.includes("unique constraint") || error.includes("duplicate key")) {
+    suggestions.push(
+      "Unique constraint violation. Use ctx.data.dedup() to remove duplicates before adding the unique constraint."
+    );
+  }
+  if (error.includes("type") && (error.includes("cast") || error.includes("convert"))) {
+    suggestions.push(
+      "Type conversion error. Add an explicit USING clause for the type change, or use ctx.data.transform() to convert values before altering the column type."
+    );
+  }
+  if (suggestions.length === 0) {
+    suggestions.push(
+      `Migration "${failedMigration.name}" failed with: ${error}. Review the migration SQL and test on a development database.`
+    );
+  }
+  return suggestions;
+}
+
+// libs/migrations/src/lib/helpers/data-helpers.ts
+function createDataHelpers(db, dialect) {
+  const ph = (index) => dialect === "postgresql" ? `$${index}` : "?";
+  return {
+    async backfill(table, column, value, options) {
+      const where = options?.where ? ` AND (${options.where})` : "";
+      const batchSize = options?.batchSize ?? 1e3;
+      let totalAffected = 0;
+      if (dialect === "postgresql") {
+        let affected;
+        do {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${ph(1)}
+						 WHERE ctid IN (
+							SELECT ctid FROM "${table}"
+							WHERE "${column}" IS NULL${where}
+							LIMIT ${batchSize}
+						 )`,
+            [value]
+          );
+          totalAffected += affected;
+        } while (affected >= batchSize);
+      } else {
+        let affected;
+        do {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${ph(1)}
+						 WHERE rowid IN (
+							SELECT rowid FROM "${table}"
+							WHERE "${column}" IS NULL${where}
+							LIMIT ${batchSize}
+						 )`,
+            [value]
+          );
+          totalAffected += affected;
+        } while (affected >= batchSize);
+      }
+      return totalAffected;
+    },
+    async transform(table, column, sqlExpression, options) {
+      const where = options?.where ? ` WHERE ${options.where}` : "";
+      const batchSize = options?.batchSize ?? 0;
+      if (batchSize <= 0) {
+        return db.execute(
+          `UPDATE "${table}" SET "${column}" = ${sqlExpression}${where}`
+        );
+      }
+      let totalAffected = 0;
+      let affected;
+      do {
+        if (dialect === "postgresql") {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${sqlExpression}
+						 WHERE ctid IN (
+							SELECT ctid FROM "${table}"${where}
+							LIMIT ${batchSize}
+						 )`
+          );
+        } else {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${sqlExpression}
+						 WHERE rowid IN (
+							SELECT rowid FROM "${table}"${where}
+							LIMIT ${batchSize}
+						 )`
+          );
+        }
+        totalAffected += affected;
+      } while (affected >= batchSize);
+      return totalAffected;
+    },
+    async renameColumn(table, from, to, columnType) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${to}" ${columnType}`
+      );
+      await db.execute(
+        `UPDATE "${table}" SET "${to}" = "${from}"`
+      );
+      await db.execute(
+        `ALTER TABLE "${table}" DROP COLUMN "${from}"`
+      );
+    },
+    async splitColumn(table, _sourceColumn, targets) {
+      for (const target of targets) {
+        await db.execute(
+          `ALTER TABLE "${table}" ADD COLUMN "${target.name}" ${target.type}`
+        );
+        await db.execute(
+          `UPDATE "${table}" SET "${target.name}" = ${target.expression}`
+        );
+      }
+    },
+    async mergeColumns(table, _sourceColumns, targetColumn, targetType, mergeExpression) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${targetColumn}" ${targetType}`
+      );
+      await db.execute(
+        `UPDATE "${table}" SET "${targetColumn}" = ${mergeExpression}`
+      );
+    },
+    async copyData(sourceTable, targetTable, columnMapping, options) {
+      const targetCols = [];
+      const sourceCols = [];
+      for (const [target, source] of Object.entries(columnMapping)) {
+        targetCols.push(`"${target}"`);
+        if (typeof source === "string") {
+          sourceCols.push(`"${source}"`);
+        } else {
+          sourceCols.push(source.expression);
+        }
+      }
+      const where = options?.where ? ` WHERE ${options.where}` : "";
+      const affected = await db.execute(
+        `INSERT INTO "${targetTable}" (${targetCols.join(", ")})
+				 SELECT ${sourceCols.join(", ")} FROM "${sourceTable}"${where}`
+      );
+      return affected;
+    },
+    async columnToJson(table, sourceColumn, jsonColumn, jsonKey) {
+      if (dialect === "postgresql") {
+        await db.execute(
+          `UPDATE "${table}" SET "${jsonColumn}" = COALESCE("${jsonColumn}", '{}'::jsonb) || jsonb_build_object('${jsonKey}', "${sourceColumn}")`
+        );
+      } else {
+        await db.execute(
+          `UPDATE "${table}" SET "${jsonColumn}" = json_set(COALESCE("${jsonColumn}", '{}'), '$.${jsonKey}', "${sourceColumn}")`
+        );
+      }
+    },
+    async jsonToColumn(table, jsonColumn, jsonKey, targetColumn, targetType) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${targetColumn}" ${targetType}`
+      );
+      if (dialect === "postgresql") {
+        await db.execute(
+          `UPDATE "${table}" SET "${targetColumn}" = "${jsonColumn}"->>'${jsonKey}'`
+        );
+      } else {
+        await db.execute(
+          `UPDATE "${table}" SET "${targetColumn}" = json_extract("${jsonColumn}", '$.${jsonKey}')`
+        );
+      }
+    },
+    async dedup(table, columns, keepStrategy = "latest") {
+      const colList = columns.map((c) => `"${c}"`).join(", ");
+      let orderBy;
+      switch (keepStrategy) {
+        case "earliest":
+          orderBy = '"createdAt" ASC';
+          break;
+        case "first":
+          orderBy = dialect === "postgresql" ? "ctid ASC" : "rowid ASC";
+          break;
+        default:
+          orderBy = '"createdAt" DESC';
+          break;
+      }
+      if (dialect === "postgresql") {
+        return db.execute(
+          `DELETE FROM "${table}" WHERE ctid NOT IN (
+						SELECT DISTINCT ON (${colList}) ctid
+						FROM "${table}"
+						ORDER BY ${colList}, ${orderBy}
+					)`
+        );
+      }
+      return db.execute(
+        `DELETE FROM "${table}" WHERE rowid NOT IN (
+					SELECT MIN(rowid) FROM "${table}"
+					GROUP BY ${colList}
+				)`
+      );
+    }
+  };
+}
+
+// libs/migrations/src/lib/loader/migration-loader.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var MIGRATION_FILE_PATTERN = /^\d{14}_.+\.ts$/;
+function isMigrationFile(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return "meta" in obj && typeof obj["meta"] === "object" && obj["meta"] !== null && "up" in obj && typeof obj["up"] === "function" && "down" in obj && typeof obj["down"] === "function";
+}
+function validateMigrationModule(mod, filePath) {
+  const file = mod["default"] ?? mod;
+  if (!isMigrationFile(file)) {
+    if (typeof file !== "object" || file === null) {
+      throw new Error(`Migration file ${filePath} does not export a valid module`);
+    }
+    if (!("meta" in file) || typeof file["meta"] !== "object") {
+      throw new Error(`Migration file ${filePath} is missing a valid 'meta' export`);
+    }
+    if (!("up" in file) || typeof file["up"] !== "function") {
+      throw new Error(`Migration file ${filePath} is missing an 'up' function export`);
+    }
+    if (!("down" in file) || typeof file["down"] !== "function") {
+      throw new Error(`Migration file ${filePath} is missing a 'down' function export`);
+    }
+    throw new Error(`Migration file ${filePath} does not conform to MigrationFile interface`);
+  }
+  return file;
+}
+async function loadMigrationsFromDisk(directory) {
+  if (!(0, import_node_fs.existsSync)(directory))
+    return [];
+  const files = (0, import_node_fs.readdirSync)(directory).filter((f) => MIGRATION_FILE_PATTERN.test(f)).sort();
+  if (files.length === 0)
+    return [];
+  const migrations = [];
+  for (const filename of files) {
+    const filePath = (0, import_node_path.join)(directory, filename);
+    const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+    const mod = await import(fileUrl);
+    const file = validateMigrationModule(mod, filePath);
+    const name = filename.replace(/\.ts$/, "");
+    migrations.push({ name, file });
+  }
+  return migrations;
+}
+
+// libs/migrations/src/lib/loader/snapshot-manager.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var SNAPSHOT_FILENAME = ".snapshot.json";
+function readSnapshot(directory) {
+  const filePath = (0, import_node_path2.join)(directory, SNAPSHOT_FILENAME);
+  if (!(0, import_node_fs2.existsSync)(filePath))
+    return null;
+  const json2 = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+  return deserializeSnapshot(json2);
+}
+function writeSnapshot(directory, snapshot) {
+  (0, import_node_fs2.mkdirSync)(directory, { recursive: true });
+  const filePath = (0, import_node_path2.join)(directory, SNAPSHOT_FILENAME);
+  (0, import_node_fs2.writeFileSync)(filePath, serializeSnapshot(snapshot), "utf-8");
+}
+function getSnapshotPath(directory) {
+  return (0, import_node_path2.join)(directory, SNAPSHOT_FILENAME);
+}
+
+// libs/migrations/src/cli/shared.ts
+function resolveDialect(adapter) {
+  if (!adapter.dialect) {
+    throw new Error(
+      "DatabaseAdapter.dialect is not set. Ensure your adapter factory (postgresAdapter/sqliteAdapter) sets the dialect property."
+    );
+  }
+  return adapter.dialect;
+}
+function buildTrackerFromAdapter(adapter) {
+  if (!adapter.queryRaw || !adapter.executeRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw and executeRaw for migration tracking");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  const executeRaw = adapter.executeRaw.bind(adapter);
+  return {
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    },
+    async execute(sql, params) {
+      return executeRaw(sql, params);
+    }
+  };
+}
+function buildContextFromAdapter(adapter, dialect) {
+  if (!adapter.queryRaw || !adapter.executeRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw and executeRaw for migration context");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  const executeRaw = adapter.executeRaw.bind(adapter);
+  const dataDb = {
+    async execute(sql, params) {
+      return executeRaw(sql, params);
+    },
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    }
+  };
+  const helpers = createDataHelpers(dataDb, dialect);
+  return {
+    async sql(query, params) {
+      await executeRaw(query, params);
+    },
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    },
+    data: helpers,
+    dialect,
+    log: {
+      info: (msg) => {
+        console.warn(`[migration] ${msg}`);
+      },
+      warn: (msg) => {
+        console.warn(`[migration:warn] ${msg}`);
+      }
+    }
+  };
+}
+function buildPushDbFromAdapter(adapter) {
+  if (!adapter.executeRaw) {
+    throw new Error("DatabaseAdapter must implement executeRaw for push mode");
+  }
+  const executeRaw = adapter.executeRaw.bind(adapter);
+  return {
+    async executeRaw(sql) {
+      return executeRaw(sql);
+    }
+  };
+}
+function buildCloneDbFromAdapter(adapter) {
+  if (!adapter.cloneDatabase || !adapter.dropClone) {
+    throw new Error("DatabaseAdapter must implement cloneDatabase and dropClone for clone-test-apply");
+  }
+  return {
+    cloneDatabase: adapter.cloneDatabase.bind(adapter),
+    dropClone: adapter.dropClone.bind(adapter)
+  };
+}
+function buildIntrospector(adapter, dialect) {
+  if (!adapter.queryRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw for introspection");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  if (dialect === "postgresql") {
+    const queryFn2 = async (sql, params) => queryRaw(sql, params);
+    return () => introspectPostgres(queryFn2);
+  }
+  const queryFn = async (sql, params) => queryRaw(sql, params);
+  return () => introspectSqlite(queryFn);
+}
+function parseMigrationArgs(args) {
+  const configPath = args.find((a) => !a.startsWith("--"));
+  if (!configPath) {
+    throw new Error("Usage: npx tsx <command>.ts <configPath> [options]");
+  }
+  let name;
+  const nameIdx = args.indexOf("--name");
+  if (nameIdx !== -1 && args[nameIdx + 1]) {
+    name = args[nameIdx + 1];
+  }
+  return {
+    configPath,
+    name,
+    dryRun: args.includes("--dry-run"),
+    testOnly: args.includes("--test-only"),
+    skipCloneTest: args.includes("--skip-clone-test")
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERNAL_TABLES,
+  MIGRATION_TRACKING_TABLE,
+  areTypesCompatible,
+  buildCloneDbFromAdapter,
+  buildContextFromAdapter,
+  buildIntrospector,
+  buildPushDbFromAdapter,
+  buildTrackerFromAdapter,
+  cloneTestApply,
+  collectionToTableSnapshot,
+  collectionsToSchema,
+  computeSchemaChecksum,
+  createDataHelpers,
+  createSchemaSnapshot,
+  deserializeSnapshot,
+  detectDangers,
+  diffSchemas,
+  ensureTrackingTable,
+  fieldToColumnType,
+  fieldToPostgresType,
+  fieldToSqliteType,
+  generateMigrationFileContent,
+  generateMigrationName,
+  getAppliedMigrations,
+  getLatestBatchNumber,
+  getMigrationStatus,
+  getMigrationsByBatch,
+  getNextBatchNumber,
+  getSnapshotPath,
+  introspectPostgres,
+  introspectSqlite,
+  isMigrationApplied,
+  loadMigrationsFromDisk,
+  normalizeColumnType,
+  operationToReverseSql,
+  operationToSql,
+  operationsToDownSql,
+  operationsToUpSql,
+  parseMigrationArgs,
+  readSnapshot,
+  recordMigration,
+  removeMigrationRecord,
+  resolveDialect,
+  rollbackBatch,
+  runMigrations,
+  runPush,
+  serializeSnapshot,
+  writeSnapshot
+});