@korajs/cli 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/bin.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
-import {
-  createCommand
-} from "./chunk-Z7GCXMGW.js";
 import {
   agentsCommand,
   deployCommand,
   generateTypes
-} from "./chunk-4IKCHRJ6.js";
+} from "./chunk-TVIRMDER.js";
+import {
+  createCommand
+} from "./chunk-TIKGLNER.js";
 import {
   DevServerError,
   InvalidProjectError,
   SchemaNotFoundError,
   createLogger,
   promptConfirm
-} from "./chunk-G2PBYMMA.js";
+} from "./chunk-7Y4J2GXP.js";
 import {
   loadSchemaDefinition
 } from "./chunk-6C4BHSRA.js";
@@ -1620,8 +1620,8 @@ function isBreakingChange(change) {
   if (change.type === "field-changed") {
     if (change.before.kind !== change.after.kind) return true;
     if (change.before.itemKind !== change.after.itemKind) return true;
-    if (serializeEnum(change.before.enumValues) !== serializeEnum(change.after.enumValues))
-      return true;
+    const kept = new Set(change.after.enumValues ?? []);
+    if ((change.before.enumValues ?? []).some((value) => !kept.has(value))) return true;
     if (change.before.required !== change.after.required && change.after.required) return true;
     return false;
   }
@@ -1650,22 +1650,484 @@ function compareChanges(left, right) {
   return 0;
 }
 
+// src/commands/migrate/table-evolution-directive.ts
+import {
+  collectionIndexName,
+  isKoraInternalColumn,
+  parseSqliteCheckConstraints,
+  readSqliteTableCatalog,
+  sqlDefaultLiteral,
+  sqliteCheckConstraintDefinition,
+  sqliteCheckReferencesColumn
+} from "@korajs/core/internal";
+var EVOLVE_TABLE_DIRECTIVE = "--kora:evolve-table";
+function evolveFieldSpec(descriptor) {
+  return {
+    kind: descriptor.kind,
+    ...descriptor.itemKind ? { itemKind: descriptor.itemKind } : {},
+    ...descriptor.enumValues ? { enumValues: [...descriptor.enumValues] } : {},
+    ...descriptor.defaultValue !== void 0 ? { default: descriptor.defaultValue } : {},
+    ...descriptor.auto ? { auto: true } : {}
+  };
+}
+function formatEvolveTableDirective(target) {
+  return `${EVOLVE_TABLE_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseEvolveTableDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(EVOLVE_TABLE_DIRECTIVE)) return null;
+  const payload = trimmed.slice(EVOLVE_TABLE_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  const target = parsed;
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+  const isSpec = (value) => isRecord(value) && typeof value.kind === "string";
+  if (!isRecord(target) || typeof target.table !== "string" || !isRecord(target.add) || !Object.values(target.add).every(isSpec) || !isStrings(target.drop) || !isRecord(target.change) || !Object.values(target.change).every(
+    (change) => isRecord(change) && isSpec(change.from) && isSpec(change.to)
+  ) || !isStrings(target.addIndexes) || !isStrings(target.removeIndexes)) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${EVOLVE_TABLE_DIRECTIVE} {"table", "add", "drop", "change", "addIndexes", "removeIndexes"}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  return {
+    table: target.table,
+    add: target.add,
+    drop: [...target.drop],
+    change: target.change,
+    addIndexes: [...target.addIndexes],
+    removeIndexes: [...target.removeIndexes]
+  };
+}
+async function expandEvolveTableForSqlite(target, query, now) {
+  const catalog = await readSqliteTableCatalog(query, target.table);
+  if (!catalog) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(
+    catalog.columns.map((column) => [column.name, column.type.toUpperCase()])
+  );
+  const plan = planColumns(target, existing, sqliteType);
+  const statements = [];
+  const presentIndexes = await indexColumnsByName(query, target.table);
+  const removedIndexNames = new Set(
+    target.removeIndexes.flatMap((field) => koraIndexNames(target.table, field)).filter((name) => presentIndexes.has(name))
+  );
+  for (const name of removedIndexNames) {
+    statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(name)}`);
+  }
+  if (plan.drop.length > 0 || plan.change.length > 0) {
+    statements.push(
+      ...await sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now)
+    );
+  } else {
+    for (const [field, spec] of plan.add) {
+      statements.push(
+        `ALTER TABLE ${table} ADD COLUMN ${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`
+      );
+      if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+        statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+      }
+    }
+  }
+  const indexed = await singleColumnIndexes(query, target.table, removedIndexNames);
+  for (const field of target.addIndexes) {
+    if (indexed.has(field)) continue;
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS ${koraIndexNames(target.table, field)[0]} ON ${table} (${quoteIdentifier(field)})`
+    );
+  }
+  return statements;
+}
+async function expandEvolveTableForPostgres(target, query, now) {
+  const columns = await query(
+    `SELECT column_name::text AS name, upper(data_type::text) AS type FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ${sqlText(target.table)}`
+  );
+  if (columns.length === 0) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(columns.map((row) => [String(row.name), String(row.type)]));
+  const plan = planColumns(target, existing, postgresType);
+  const statements = [];
+  const indexNames = new Set(
+    (await query(
+      `SELECT indexname::text AS name FROM pg_indexes WHERE schemaname = current_schema() AND tablename = ${sqlText(target.table)}`
+    )).map((row) => String(row.name))
+  );
+  for (const field of target.removeIndexes) {
+    const [serverName, clientName] = koraIndexNames(target.table, field);
+    if (indexNames.has(serverName.toLowerCase())) {
+      statements.push(`DROP INDEX IF EXISTS ${serverName}`);
+    }
+    if (indexNames.has(clientName)) {
+      statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(clientName)}`);
+    }
+  }
+  for (const field of plan.drop) {
+    statements.push(`ALTER TABLE ${table} DROP COLUMN IF EXISTS ${quoteIdentifier(field)}`);
+  }
+  for (const [field, change] of plan.change) {
+    const column = quoteIdentifier(field);
+    const type = postgresType(change.to);
+    statements.push(`ALTER TABLE ${table} ALTER COLUMN ${column} DROP DEFAULT`);
+    statements.push(
+      `ALTER TABLE ${table} ALTER COLUMN ${column} TYPE ${type} USING CAST((${postgresProjection(column, change.from, change.to, now)}) AS ${type})`
+    );
+    if (change.to.default !== void 0) {
+      statements.push(
+        `ALTER TABLE ${table} ALTER COLUMN ${column} SET DEFAULT ${sqlDefaultLiteral(change.to.default)}`
+      );
+    }
+  }
+  for (const [field, spec] of plan.add) {
+    statements.push(
+      `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${quoteIdentifier(field)} ${postgresType(spec)}${defaultClause(spec)}`
+    );
+    if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+      statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+    }
+  }
+  for (const field of target.addIndexes) {
+    const name = koraIndexNames(target.table, field)[0];
+    if (indexNames.has(name.toLowerCase())) continue;
+    statements.push(`CREATE INDEX IF NOT EXISTS ${name} ON ${table} (${quoteIdentifier(field)})`);
+  }
+  return statements;
+}
+function planColumns(target, existing, typeOf) {
+  const plan = { add: [], drop: [], change: [] };
+  for (const [field, spec] of Object.entries(target.add)) {
+    if (!existing.has(field)) plan.add.push([field, spec]);
+  }
+  for (const [field, change] of Object.entries(target.change)) {
+    const current = existing.get(field);
+    if (current === void 0) {
+      plan.add.push([field, change.to]);
+      continue;
+    }
+    const from = typeOf(change.from);
+    const to = typeOf(change.to);
+    if (from !== to && current === to) continue;
+    plan.change.push([field, change]);
+  }
+  for (const field of target.drop) {
+    if (existing.has(field) && !(field in target.add) && !(field in target.change)) {
+      if (isKoraInternalColumn(field)) {
+        throw new Error(
+          `Migration directive refuses to drop Kora's own column "${field}" of "${target.table}".`
+        );
+      }
+      plan.drop.push(field);
+    }
+  }
+  return plan;
+}
+async function sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now) {
+  const table = catalog.table;
+  const temp = `_kora_evolve_${table}`;
+  const dropped = new Set(plan.drop);
+  const changed = new Map(plan.change);
+  const ordered = [...catalog.columns].sort((a, b) => a.cid - b.cid).filter((column) => !dropped.has(column.name));
+  const pkColumns = ordered.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk);
+  const fkGroups = /* @__PURE__ */ new Map();
+  for (const fk of catalog.foreignKeys) {
+    const group = fkGroups.get(fk.id) ?? [];
+    group.push(fk);
+    fkGroups.set(fk.id, group);
+  }
+  const columnReferences = /* @__PURE__ */ new Map();
+  const tableConstraints = [];
+  for (const group of fkGroups.values()) {
+    group.sort((a, b) => a.seq - b.seq);
+    const first = group[0];
+    if (!first || group.some((fk) => dropped.has(fk.from))) continue;
+    const actions = foreignKeyActions(first);
+    const targetRef = group.every((fk) => fk.to !== null && fk.to !== "") ? `${quoteIdentifier(first.table)}(${group.map((fk) => quoteIdentifier(fk.to ?? "")).join(", ")})` : quoteIdentifier(first.table);
+    if (group.length === 1) {
+      columnReferences.set(first.from, `REFERENCES ${targetRef}${actions}`);
+    } else {
+      tableConstraints.push(
+        `FOREIGN KEY (${group.map((fk) => quoteIdentifier(fk.from)).join(", ")}) REFERENCES ${targetRef}${actions}`
+      );
+    }
+  }
+  if (pkColumns.length > 1) {
+    tableConstraints.unshift(
+      `PRIMARY KEY (${pkColumns.map((c) => quoteIdentifier(c.name)).join(", ")})`
+    );
+  }
+  for (const unique of catalog.uniqueConstraints) {
+    if (unique.some((column) => dropped.has(column))) continue;
+    tableConstraints.push(`UNIQUE (${unique.map(quoteIdentifier).join(", ")})`);
+  }
+  for (const check of parseSqliteCheckConstraints(catalog.sql)) {
+    if (sqliteCheckReferencesColumn(check, dropped)) continue;
+    tableConstraints.push(sqliteCheckConstraintDefinition(check));
+  }
+  const definitions = [];
+  const targetColumns = [];
+  const selections = [];
+  for (const column of ordered) {
+    const change = changed.get(column.name);
+    const parts = [quoteIdentifier(column.name)];
+    if (change) {
+      parts.push(sqliteType(change.to));
+    } else if (column.type) {
+      parts.push(column.type);
+    }
+    if (pkColumns.length === 1 && column.pk === 1) parts.push("PRIMARY KEY");
+    if (column.notnull === 1) parts.push("NOT NULL");
+    if (change) {
+      if (change.to.default !== void 0) {
+        parts.push(`DEFAULT ${sqlDefaultLiteral(change.to.default)}`);
+      }
+    } else if (column.dflt_value !== null) {
+      parts.push(`DEFAULT (${column.dflt_value})`);
+    }
+    const reference = columnReferences.get(column.name);
+    if (reference) parts.push(reference);
+    definitions.push(parts.join(" "));
+    targetColumns.push(quoteIdentifier(column.name));
+    selections.push(
+      change ? sqliteProjection(quoteIdentifier(column.name), change.from, change.to, now) : quoteIdentifier(column.name)
+    );
+  }
+  for (const [field, spec] of plan.add) {
+    definitions.push(`${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`);
+    targetColumns.push(quoteIdentifier(field));
+    selections.push(fallbackLiteral(spec, now));
+  }
+  const indexColumns = await indexColumnsByName(query, table);
+  const dependents = [];
+  for (const row of await query(
+    `SELECT type, name, sql FROM sqlite_master WHERE type IN ('index', 'trigger') AND tbl_name = ${sqlText(table)} AND sql IS NOT NULL ORDER BY type, name`
+  )) {
+    const name = String(row.name);
+    if (row.type === "index") {
+      if (removedIndexNames.has(name)) continue;
+      if ((indexColumns.get(name) ?? []).some((column) => dropped.has(column))) continue;
+    }
+    dependents.push(String(row.sql));
+  }
+  return [
+    `DROP TABLE IF EXISTS ${quoteIdentifier(temp)}`,
+    `CREATE TABLE ${quoteIdentifier(temp)} (
+  ${[...definitions, ...tableConstraints].join(",\n  ")}
+)`,
+    `INSERT INTO ${quoteIdentifier(temp)} (${targetColumns.join(", ")}) SELECT ${selections.join(", ")} FROM ${quoteIdentifier(table)}`,
+    `DROP TABLE ${quoteIdentifier(table)}`,
+    `ALTER TABLE ${quoteIdentifier(temp)} RENAME TO ${quoteIdentifier(table)}`,
+    ...dependents
+  ];
+}
+async function indexColumnsByName(query, table) {
+  const out = /* @__PURE__ */ new Map();
+  for (const index of await query(`SELECT name FROM pragma_index_list(${sqlText(table)})`)) {
+    const name = String(index.name);
+    const info = await query(`SELECT name FROM pragma_index_info(${sqlText(name)}) ORDER BY seqno`);
+    out.set(
+      name,
+      info.filter((row) => typeof row.name === "string").map((row) => String(row.name))
+    );
+  }
+  return out;
+}
+async function singleColumnIndexes(query, table, ignore) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [name, columns] of await indexColumnsByName(query, table)) {
+    if (ignore.has(name)) continue;
+    const only = columns[0];
+    if (columns.length === 1 && only !== void 0) out.add(only);
+  }
+  return out;
+}
+function koraIndexNames(table, field) {
+  quoteIdentifier(table);
+  quoteIdentifier(field);
+  return [`idx_${table}_${field}`, collectionIndexName(table, field)];
+}
+function defaultClause(spec) {
+  return spec.default !== void 0 ? ` DEFAULT ${sqlDefaultLiteral(spec.default)}` : "";
+}
+function sqliteType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "REAL";
+    case "boolean":
+    case "timestamp":
+      return "INTEGER";
+    case "richtext":
+      return "BLOB";
+    default:
+      return "TEXT";
+  }
+}
+function postgresType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "DOUBLE PRECISION";
+    case "boolean":
+      return "INTEGER";
+    case "timestamp":
+      return "BIGINT";
+    case "array":
+    case "object":
+    case "json":
+      return "JSONB";
+    case "richtext":
+      return "BYTEA";
+    default:
+      return "TEXT";
+  }
+}
+function fallbackLiteral(target, now) {
+  if (target.auto && target.kind === "timestamp") return String(now);
+  if (target.default !== void 0) return sqlDefaultLiteral(target.default);
+  return "NULL";
+}
+var NUMERIC_SOURCES = /* @__PURE__ */ new Set(["number", "timestamp", "boolean"]);
+var TEXT_SOURCES = /* @__PURE__ */ new Set(["string", "enum"]);
+var TRUE_WORDS = "('1','true','t','yes','y','on')";
+var FALSE_WORDS = "('0','false','f','no','n','off')";
+function sqliteProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  if (target.kind === "string") return `CAST(${column} AS TEXT)`;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    if (NUMERIC_SOURCES.has(source.kind) || TEXT_SOURCES.has(source.kind)) {
+      const castType = target.kind === "number" ? "REAL" : "INTEGER";
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE CAST(${column} AS ${castType}) END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN CAST(${column} AS REAL) = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `LOWER(TRIM(CAST(${column} AS TEXT)))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => sqlDefaultLiteral(value)).join(", ");
+      return `CASE WHEN ${column} IN (${allowed}) THEN ${column} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function postgresProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  const text = `(${column})::text`;
+  if (target.kind === "string") return text;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    const toTarget = (value) => target.kind === "number" ? value : `round(${value})::bigint`;
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE ${toTarget(`(${column})::double precision`)} END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const trimmed = `btrim(${text})`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${trimmed} ~ '^[-+]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][-+]?[0-9]+)?$' THEN ${toTarget(`(${trimmed})::double precision`)} ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN (${column})::double precision = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `lower(btrim(${text}))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => sqlDefaultLiteral(value)).join(", ");
+      return `CASE WHEN ${text} IN (${allowed}) THEN ${text} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function foreignKeyActions(fk) {
+  let out = "";
+  const onDelete = fk.on_delete?.toUpperCase();
+  const onUpdate = fk.on_update?.toUpperCase();
+  if (onDelete && onDelete !== "NO ACTION") out += ` ON DELETE ${onDelete}`;
+  if (onUpdate && onUpdate !== "NO ACTION") out += ` ON UPDATE ${onUpdate}`;
+  return out;
+}
+function sqlText(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function quoteIdentifier(identifier) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return `"${identifier}"`;
+}
+
+// src/commands/migrate/value-domain-directive.ts
+import {
+  planPostgresConstraintRelaxation,
+  planSqliteConstraintRelaxation
+} from "@korajs/core/internal";
+var RELAX_VALUE_DOMAIN_DIRECTIVE = "--kora:relax-value-domain";
+function formatRelaxValueDomainDirective(target) {
+  return `${RELAX_VALUE_DOMAIN_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseRelaxValueDomainDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(RELAX_VALUE_DOMAIN_DIRECTIVE)) return null;
+  const payload = trimmed.slice(RELAX_VALUE_DOMAIN_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.table !== "string" || !Array.isArray(parsed.fields) || !parsed.fields.every((field) => typeof field === "string") || parsed.enums !== void 0 && (!Array.isArray(parsed.enums) || !parsed.enums.every((field) => typeof field === "string"))) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${RELAX_VALUE_DOMAIN_DIRECTIVE} {"table": "...", "fields": ["..."]}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  const target = parsed;
+  return {
+    table: target.table,
+    fields: [...target.fields],
+    ...target.enums !== void 0 ? { enums: [...target.enums] } : {}
+  };
+}
+async function expandRelaxValueDomainForSqlite(target, query) {
+  return planSqliteConstraintRelaxation(query, [target.table], {
+    [target.table]: target.enums ?? target.fields
+  });
+}
+async function expandRelaxValueDomainForPostgres(target, query) {
+  return planPostgresConstraintRelaxation(
+    query,
+    { [target.table]: target.fields },
+    target.enums !== void 0 ? { [target.table]: target.enums } : {}
+  );
+}
+
 // src/commands/migrate/migration-generator.ts
 function generateMigration(previous, current, diff) {
   const up = [];
-  const down = [];
+  const downGroups = [];
   for (const change of diff.changes) {
     if (change.type === "collection-added") {
       const collectionDef = current.collections[change.collection];
       if (!collectionDef) continue;
       up.push(...generateSQL(change.collection, collectionDef));
-      down.push(...dropCollectionStatements(change.collection));
+      downGroups.push(dropCollectionStatements(change.collection));
     }
     if (change.type === "collection-removed") {
       const collectionDef = previous.collections[change.collection];
       up.push(...dropCollectionStatements(change.collection));
       if (collectionDef) {
-        down.push(...generateSQL(change.collection, collectionDef));
+        downGroups.push(generateSQL(change.collection, collectionDef));
       }
     }
   }
@@ -1678,48 +2140,59 @@ function generateMigration(previous, current, diff) {
     const previousDef = previous.collections[collection];
     const currentDef = current.collections[collection];
     if (!previousDef || !currentDef) continue;
+    const valueDomainOnly = diff.changes.every(
+      (change) => change.collection !== collection || change.type === "field-changed" && isValueDomainChange(change.before, change.after)
+    );
+    if (valueDomainOnly) {
+      const directive = relaxValueDomainDirective(collection, previousDef, currentDef);
+      up.push(directive);
+      downGroups.push([directive]);
+      continue;
+    }
     validateRebuildSafety(collection, previousDef, currentDef);
-    up.push(...generateRebuildStatements(collection, previousDef, currentDef));
-    down.push(...generateRebuildStatements(collection, currentDef, previousDef));
+    const relax = relaxValueDomainDirective(collection, previousDef, currentDef);
+    up.push(relax, formatEvolveTableDirective(evolveTarget(collection, previousDef, currentDef)));
+    downGroups.push([
+      relax,
+      formatEvolveTableDirective(evolveTarget(collection, currentDef, previousDef))
+    ]);
   }
-  down.reverse();
   return {
     up,
-    down,
+    down: downGroups.reverse().flat(),
     summary: diff.changes.map(formatChange),
     containsBreakingChanges: diff.hasBreakingChanges
   };
 }
-function generateRebuildStatements(collection, from, to) {
-  const table = quoteIdentifier(collection);
-  const tempTable = quoteIdentifier(`_kora_mig_${collection}_new`);
-  const targetColumns = [
-    "id TEXT PRIMARY KEY NOT NULL",
-    ...Object.entries(to.fields).map(([field, descriptor]) => columnDefinition(field, descriptor)),
-    "_created_at INTEGER NOT NULL",
-    "_updated_at INTEGER NOT NULL",
-    "_deleted INTEGER NOT NULL DEFAULT 0"
-  ];
-  const statements = [];
-  statements.push(`CREATE TABLE ${tempTable} (
-  ${targetColumns.join(",\n  ")}
-)`);
-  const toFields = Object.keys(to.fields);
-  const columns = ["id", ...toFields, "_created_at", "_updated_at", "_deleted"];
-  const selectExpressions = columns.map(
-    (column) => projectionForColumn(column, from.fields, to.fields[column] ?? null)
-  );
-  statements.push(
-    `INSERT INTO ${tempTable} (${columns.map(quoteIdentifier).join(", ")}) SELECT ${selectExpressions.join(", ")} FROM ${table}`
-  );
-  statements.push(`DROP TABLE ${table}`);
-  statements.push(`ALTER TABLE ${tempTable} RENAME TO ${table}`);
-  for (const indexField of to.indexes) {
-    statements.push(
-      `CREATE INDEX IF NOT EXISTS idx_${collection}_${indexField} ON ${table} (${quoteIdentifier(indexField)})`
-    );
+function isValueDomainChange(before, after) {
+  return before.kind === after.kind && before.itemKind === after.itemKind && before.auto === after.auto;
+}
+function evolveTarget(collection, from, to) {
+  const target = {
+    table: collection,
+    add: {},
+    drop: [],
+    change: {},
+    addIndexes: to.indexes.filter((field) => !from.indexes.includes(field)),
+    removeIndexes: from.indexes.filter((field) => !to.indexes.includes(field))
+  };
+  for (const [field, descriptor] of Object.entries(to.fields)) {
+    const before = from.fields[field];
+    if (!before) {
+      target.add[field] = evolveFieldSpec(descriptor);
+    } else if (before.kind !== descriptor.kind || before.itemKind !== descriptor.itemKind) {
+      target.change[field] = { from: evolveFieldSpec(before), to: evolveFieldSpec(descriptor) };
+    }
   }
-  return statements;
+  target.drop = Object.keys(from.fields).filter((field) => !(field in to.fields));
+  return target;
+}
+function relaxValueDomainDirective(collection, from, to) {
+  const fields = [.../* @__PURE__ */ new Set([...Object.keys(from.fields), ...Object.keys(to.fields)])].sort();
+  const enums = fields.filter(
+    (field) => from.fields[field]?.kind === "enum" || to.fields[field]?.kind === "enum"
+  );
+  return formatRelaxValueDomainDirective({ table: collection, fields, enums });
 }
 function validateRebuildSafety(collection, from, to) {
   for (const [fieldName, descriptor] of Object.entries(to.fields)) {
@@ -1741,69 +2214,6 @@ function validateRebuildSafety(collection, from, to) {
     }
   }
 }
-function projectionForColumn(column, fromFields, targetDescriptor) {
-  if (column === "id" || column === "_created_at" || column === "_updated_at" || column === "_deleted") {
-    return quoteIdentifier(column);
-  }
-  const sourceDescriptor = fromFields[column];
-  if (sourceDescriptor && targetDescriptor) {
-    return projectionForFieldTransform(column, sourceDescriptor, targetDescriptor);
-  }
-  if (sourceDescriptor) {
-    return quoteIdentifier(column);
-  }
-  if (!targetDescriptor) {
-    return "NULL";
-  }
-  if (targetDescriptor.auto && targetDescriptor.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  if (targetDescriptor.defaultValue !== void 0) {
-    return sqlLiteral(targetDescriptor.defaultValue);
-  }
-  return "NULL";
-}
-function projectionForFieldTransform(column, source, target) {
-  const sourceColumn = quoteIdentifier(column);
-  if (source.kind === target.kind && source.itemKind === target.itemKind) {
-    if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
-      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
-      const fallback = target.defaultValue !== void 0 ? sqlLiteral(target.defaultValue) : sourceColumn;
-      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${fallback} END`;
-    }
-    return sourceColumn;
-  }
-  if (target.kind === "string") {
-    return `CAST(${sourceColumn} AS TEXT)`;
-  }
-  if (target.kind === "number" || target.kind === "timestamp") {
-    if (source.kind === "string" || source.kind === "enum" || source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
-      const castType = target.kind === "number" ? "REAL" : "INTEGER";
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL ELSE CAST(${sourceColumn} AS ${castType}) END`;
-    }
-  }
-  if (target.kind === "boolean") {
-    if (source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN CAST(${sourceColumn} AS REAL) = 0 THEN 0 ELSE 1 END`;
-    }
-    if (source.kind === "string" || source.kind === "enum") {
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('1','true','t','yes','y','on') THEN 1 WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('0','false','f','no','n','off') THEN 0 ELSE ${projectionFallback(target)} END`;
-    }
-  }
-  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
-    if (source.kind === "string" || source.kind === "enum") {
-      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
-      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${projectionFallback(target)} END`;
-    }
-  }
-  if (target.kind === "array" && source.kind === "array" && source.itemKind === target.itemKind) {
-    return sourceColumn;
-  }
-  if (target.auto && target.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  return projectionFallback(target);
-}
 function canTransformField(source, target) {
   if (source.kind === target.kind && source.itemKind === target.itemKind) {
     return true;
@@ -1828,69 +2238,12 @@ function canTransformField(source, target) {
   }
   return false;
 }
-function projectionFallback(target) {
-  if (target.auto && target.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  if (target.defaultValue !== void 0) {
-    return sqlLiteral(target.defaultValue);
-  }
-  return "NULL";
-}
 function dropCollectionStatements(collection) {
-  const table = quoteIdentifier(collection);
-  const opsTable = quoteIdentifier(`_kora_ops_${collection}`);
+  const table = quoteIdentifier2(collection);
+  const opsTable = quoteIdentifier2(`_kora_ops_${collection}`);
   return [`DROP TABLE IF EXISTS ${table}`, `DROP TABLE IF EXISTS ${opsTable}`];
 }
-function columnDefinition(fieldName, descriptor) {
-  const sqlType = mapFieldType(descriptor);
-  const parts = [quoteIdentifier(fieldName), sqlType];
-  if (descriptor.required && descriptor.defaultValue === void 0 && !descriptor.auto) {
-    parts.push("NOT NULL");
-  }
-  if (descriptor.defaultValue !== void 0) {
-    parts.push(`DEFAULT ${sqlLiteral(descriptor.defaultValue)}`);
-  }
-  if (descriptor.kind === "enum" && descriptor.enumValues) {
-    const values = descriptor.enumValues.map((value) => sqlLiteral(value)).join(", ");
-    parts.push(`CHECK (${quoteIdentifier(fieldName)} IN (${values}))`);
-  }
-  return parts.join(" ");
-}
-function mapFieldType(descriptor) {
-  switch (descriptor.kind) {
-    case "string":
-      return "TEXT";
-    case "number":
-      return "REAL";
-    case "boolean":
-      return "INTEGER";
-    case "enum":
-      return "TEXT";
-    case "timestamp":
-      return "INTEGER";
-    case "array":
-      return "TEXT";
-    case "object":
-      return "TEXT";
-    case "json":
-      return "TEXT";
-    case "blob":
-      return "TEXT";
-    case "secret":
-      return "TEXT";
-    case "richtext":
-      return "BLOB";
-  }
-}
-function sqlLiteral(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-  return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
-}
-function quoteIdentifier(identifier) {
+function quoteIdentifier2(identifier) {
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
     throw new Error(`Invalid SQL identifier: ${identifier}`);
   }
@@ -1968,6 +2321,8 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
   const driver = driverOverride ?? await loadSqliteDriver(projectRoot);
   const db = driver.open(path);
   let statementsApplied = 0;
+  const foreignKeysOn = Number(db.query?.("PRAGMA foreign_keys")[0]?.foreign_keys ?? 0) === 1;
+  if (foreignKeysOn) db.exec("PRAGMA foreign_keys = OFF");
   try {
     db.exec("BEGIN");
     db.exec(
@@ -1983,12 +2338,38 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
         skipped: true
       };
     }
+    const now = Date.now();
+    const catalogQuery = (table) => {
+      const query = db.query?.bind(db);
+      if (!query) {
+        throw new Error(
+          `Migration ${migrationId}: the SQLite driver cannot read the catalog needed to migrate "${table}".`
+        );
+      }
+      return async (text) => query(text);
+    };
     for (const statement of statements) {
-      db.exec(statement);
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForSqlite(relax, catalogQuery(relax.table));
+        for (const rebuild of expanded) db.exec(rebuild);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForSqlite(evolve, catalogQuery(evolve.table), now);
+        for (const change of expanded) db.exec(change);
+      } else {
+        db.exec(statement);
+      }
       statementsApplied++;
     }
+    const violations = db.query?.("PRAGMA foreign_key_check") ?? [];
+    if (violations.length > 0) {
+      throw new Error(
+        `Migration ${migrationId} left ${violations.length} foreign key violation(s) (first: ${JSON.stringify(violations[0])}); nothing was applied.`
+      );
+    }
     db.exec(
-      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()})`
+      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()})`
     );
     db.exec("COMMIT");
     return {
@@ -2004,6 +2385,12 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
     }
     throw error;
   } finally {
+    if (foreignKeysOn) {
+      try {
+        db.exec("PRAGMA foreign_keys = ON");
+      } catch {
+      }
+    }
     if (typeof db.close === "function") {
       db.close();
     }
@@ -2025,6 +2412,9 @@ async function loadSqliteDriver(projectRoot) {
             const row = db.prepare("SELECT COUNT(*) AS count FROM _kora_migrations WHERE id = ?").get(id);
             return (row?.count ?? 0) > 0;
           },
+          query(sql) {
+            return db.prepare(sql).all();
+          },
           close() {
             db.close();
           }
@@ -2038,7 +2428,11 @@ async function loadSqliteDriver(projectRoot) {
   }
 }
 async function runPostgresMigration(connectionString, statements, migrationId, fromVersion, toVersion, clientFactoryOverride) {
-  const sql = typeof clientFactoryOverride === "function" ? clientFactoryOverride(connectionString) : (await loadPostgresModule()).default(connectionString);
+  const sql = typeof clientFactoryOverride === "function" ? clientFactoryOverride(connectionString) : (
+    // One connection: BEGIN, the statements and COMMIT must share it (postgres.js
+    // refuses a raw BEGIN on a pool, UNSAFE_TRANSACTION).
+    (await loadPostgresModule()).default(connectionString, { max: 1 })
+  );
   let statementsApplied = 0;
   try {
     await sql.unsafe("BEGIN");
@@ -2046,7 +2440,7 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
       "CREATE TABLE IF NOT EXISTS _kora_migrations (id TEXT PRIMARY KEY, from_version INTEGER NOT NULL, to_version INTEGER NOT NULL, applied_at BIGINT NOT NULL)"
     );
     const existing = await sql.unsafe(
-      `SELECT COUNT(*)::int AS count FROM _kora_migrations WHERE id = ${sqlLiteral2(migrationId)}`
+      `SELECT COUNT(*)::int AS count FROM _kora_migrations WHERE id = ${sqlLiteral(migrationId)}`
     );
     if ((existing[0]?.count ?? 0) > 0) {
       await sql.unsafe("COMMIT");
@@ -2057,12 +2451,25 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
         skipped: true
       };
     }
+    const now = Date.now();
+    const query = async (text) => await sql.unsafe(text);
     for (const statement of statements) {
-      await sql.unsafe(statement);
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForPostgres(relax, query);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForPostgres(evolve, query, now);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else {
+        assertNotLegacyRebuild(statement, migrationId);
+        await sql.unsafe(statement);
+      }
       statementsApplied++;
     }
     await sql.unsafe(
-      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET from_version = EXCLUDED.from_version, to_version = EXCLUDED.to_version, applied_at = EXCLUDED.applied_at`
+      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET from_version = EXCLUDED.from_version, to_version = EXCLUDED.to_version, applied_at = EXCLUDED.applied_at`
     );
     await sql.unsafe("COMMIT");
     return {
@@ -2083,7 +2490,14 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
     }
   }
 }
-function sqlLiteral2(value) {
+function assertNotLegacyRebuild(statement, migrationId) {
+  if (/^\s*CREATE\s+TABLE\s+"?_kora_mig_[A-Za-z0-9_]+_new"?/i.test(statement)) {
+    throw new Error(
+      `Migration ${migrationId} was generated by an earlier \`kora migrate\` as a SQLite-only table rebuild, which cannot run on Postgres. Regenerate it: restore kora/schema.snapshot.json to the schema version it migrates from, delete the migration's files, and run \`kora migrate\` again.`
+    );
+  }
+}
+function sqlLiteral(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
 async function loadPostgresModule() {
@@ -2633,7 +3047,7 @@ var studioCommand = defineCommand9({
     if (Number.isNaN(port) || port < 0 || port > 65535) {
       throw new Error(`Invalid port "${args.port}"`);
     }
-    const { startStudioServer } = await import("./studio-server-NIFKZI4F.js");
+    const { startStudioServer } = await import("./studio-server-XLGZNGG5.js");
     if (typeof args.connect === "string") {
       if (typeof args.schema !== "string") {
         throw new Error(