@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/schema.js

@@ -1,1329 +1,1174 @@
 import { copyDate, dateMilliseconds } from "../date-value.js";
-import { validateColumnDefault, validateEnumValues, validateSqlDomain, } from "../storage/types.js";
-import { childExpressions, compileCheckExpression, expressionColumns, hasAggregate, validateDefaultExpression, } from "./query.js";
+import { validateColumnDefault, validateEnumValues, validateSqlDomain } from "../storage/types.js";
+import { childExpressions, compileCheckExpression, expressionColumns, hasAggregate, validateDefaultExpression } from "./query.js";
 import { externalSqlDomainValue, normalizeSqlDomainValue } from "./sql-domains.js";
-const volatileGeneratedFunctions = new Set([
-    "CURRENT_DATE",
-    "CURRENT_TIMESTAMP",
-    "LOCALTIME",
-    "RANDOM",
-    "GEN_RANDOM_UUID",
-    "NEXTVAL",
-    "CURRVAL",
+const volatileGeneratedFunctions = /* @__PURE__ */ new Set([
+  "CURRENT_DATE",
+  "CURRENT_TIMESTAMP",
+  "LOCALTIME",
+  "RANDOM",
+  "GEN_RANDOM_UUID",
+  "NEXTVAL",
+  "CURRVAL"
 ]);
-/** Compiles and validates one immutable, row-local generated-column expression. */
-export function compileGeneratedColumnExpression(tableName, columnName, sql, columns) {
-    if (sql.length === 0 || sql.trim() !== sql) {
-        throw new TypeError(`Generated SQL must be a trimmed non-empty expression: ${tableName}.${columnName}`);
-    }
-    const expression = compileCheckExpression(sql, `generated ${tableName}.${columnName}`);
-    if (hasAggregate(expression)) {
-        throw new TypeError(`Generated column ${tableName}.${columnName} must be an immutable expression over sibling columns`);
-    }
-    const inspect = (node) => {
-        if (node.kind === "subquery" || node.kind === "exists") {
-            throw new TypeError(`Generated column ${tableName}.${columnName} must be an immutable expression over sibling columns`);
-        }
-        if (node.kind === "call" && volatileGeneratedFunctions.has(node.name)) {
-            throw new TypeError(`Generated column ${tableName}.${columnName} cannot call volatile function ${node.name}`);
-        }
-        childExpressions(node).forEach(inspect);
-    };
-    inspect(expression);
-    for (const reference of expressionColumns(expression)) {
-        const pieces = reference.split(".");
-        const referencedName = pieces.at(-1) ?? reference;
-        const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : undefined;
-        if (qualifier !== undefined && qualifier !== tableName) {
-            throw new TypeError(`Generated column ${tableName}.${columnName} references another table: ${reference}`);
-        }
-        const referenced = columns.find(({ name }) => name === referencedName);
-        if (referenced === undefined) {
-            throw new TypeError(`Generated column ${tableName}.${columnName} names an unknown column: ${referencedName}`);
-        }
-        if (referencedName === columnName || referenced.generatedValue !== undefined) {
-            throw new TypeError(`Generated column ${tableName}.${columnName} cannot reference a generated column: ${referencedName}`);
-        }
+function compileGeneratedColumnExpression(tableName, columnName, sql, columns) {
+  if (sql.length === 0 || sql.trim() !== sql) {
+    throw new TypeError(`Generated SQL must be a trimmed non-empty expression: ${tableName}.${columnName}`);
+  }
+  const expression = compileCheckExpression(sql, `generated ${tableName}.${columnName}`);
+  if (hasAggregate(expression)) {
+    throw new TypeError(`Generated column ${tableName}.${columnName} must be an immutable expression over sibling columns`);
+  }
+  const inspect = (node) => {
+    if (node.kind === "subquery" || node.kind === "exists") {
+      throw new TypeError(`Generated column ${tableName}.${columnName} must be an immutable expression over sibling columns`);
     }
-    return expression;
-}
-/**
- * The constraint name `migrate()` gives a declared relation. It matches the name the SQL parser
- * derives for an unnamed inline REFERENCES, so a table built either way has the same catalog.
- */
-export function foreignKeyName(tableName, columnName) {
-    return `${tableName}_${columnName}_fkey`;
-}
-function defaultSpecFromArg(type, value, sqlDomain) {
-    if (sqlDomain?.kind === "numeric") {
-        if ((typeof value !== "number" || !Number.isFinite(value)) && typeof value !== "string") {
-            throw new TypeError("NUMERIC default must be a finite number or decimal string");
-        }
-        normalizeSqlDomainValue(sqlDomain, value);
-        return { kind: "literal", value };
+    if (node.kind === "call" && volatileGeneratedFunctions.has(node.name)) {
+      throw new TypeError(`Generated column ${tableName}.${columnName} cannot call volatile function ${node.name}`);
     }
-    switch (type) {
-        case "datetime":
-            if (!(value instanceof Date) || !Number.isFinite(dateMilliseconds(value))) {
-                throw new TypeError("Default literal must be a valid Date");
-            }
-            return { kind: "literal", value: copyDate(value) };
-        case "string":
-            if (typeof value !== "string")
-                throw new TypeError("Default literal must be a string");
-            return { kind: "literal", value };
-        case "number":
-            if (typeof value !== "number" || !Number.isFinite(value)) {
-                throw new TypeError("Default literal must be a finite number");
-            }
-            return { kind: "literal", value };
-        case "boolean":
-            if (typeof value !== "boolean")
-                throw new TypeError("Default literal must be a boolean");
-            return { kind: "literal", value };
+    childExpressions(node).forEach(inspect);
+  };
+  inspect(expression);
+  for (const reference of expressionColumns(expression)) {
+    const pieces = reference.split(".");
+    const referencedName = pieces.at(-1) ?? reference;
+    const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : void 0;
+    if (qualifier !== void 0 && qualifier !== tableName) {
+      throw new TypeError(`Generated column ${tableName}.${columnName} references another table: ${reference}`);
+    }
+    const referenced = columns.find(({ name }) => name === referencedName);
+    if (referenced === void 0) {
+      throw new TypeError(`Generated column ${tableName}.${columnName} names an unknown column: ${referencedName}`);
     }
+    if (referencedName === columnName || referenced.generatedValue !== void 0) {
+      throw new TypeError(`Generated column ${tableName}.${columnName} cannot reference a generated column: ${referencedName}`);
+    }
+  }
+  return expression;
 }
-function createColumn(type, state = {}) {
-    const base = {
-        kind: "column",
-        type,
-        isNullable: (state.isNullable ?? false),
-        isUnique: (state.isUnique ?? false),
-        hasDefault: (state.defaultSpec !== undefined),
-        isGenerated: (state.generatedSpec !== undefined),
-        integer: state.integer ?? false,
-        ...(state.sqlDomain === undefined ? {} : { sqlDomain: state.sqlDomain }),
-        ...(state.defaultSpec === undefined ? {} : { defaultSpec: state.defaultSpec }),
-        ...(state.generatedSpec === undefined ? {} : { generatedSpec: state.generatedSpec }),
-        ...(state.renamedFromName === undefined ? {} : { renamedFromName: state.renamedFromName }),
-        ...(state.reference === undefined ? {} : { reference: state.reference }),
-        ...(state.enumValues === undefined ? {} : { enumValues: state.enumValues }),
-        ...(state.backfillValue === undefined ? {} : { backfillValue: state.backfillValue }),
-    };
-    return {
-        ...base,
-        nullable: () => createColumn(type, {
-            ...state,
-            isNullable: true,
-        }),
-        unique: () => createColumn(type, {
-            ...state,
-            isUnique: true,
-        }),
-        renamedFrom: (name) => {
-            validateSchemaName(name, "Rename source");
-            return createColumn(type, {
-                ...state,
-                renamedFromName: name,
-            });
-        },
-        backfill: (value) => createColumn(type, {
-            ...state,
-            backfillValue: value,
-        }),
-        references: (table, referencedColumn, options = {}) => {
-            validateSchemaName(table, "Referenced table");
-            validateSchemaName(referencedColumn, "Referenced column");
-            if (options.enforced === false && options.onDelete !== undefined) {
-                throw new TypeError("An informational FOREIGN KEY cannot declare ON DELETE behavior");
-            }
-            return createColumn(type, {
-                ...state,
-                reference: {
-                    table,
-                    column: referencedColumn,
-                    onDelete: options.onDelete ?? "restrict",
-                    enforced: options.enforced !== false,
-                },
-            });
-        },
-        default: ((value) => {
-            return createColumn(type, {
-                ...state,
-                defaultSpec: defaultSpecFromArg(type, value, state.sqlDomain),
-            });
-        }),
-        defaultSql: ((sql) => {
-            const expression = sql.trim();
-            if (expression.length === 0 || expression !== sql) {
-                throw new TypeError("Default SQL must be a trimmed non-empty expression");
-            }
-            return createColumn(type, {
-                ...state,
-                defaultSpec: { kind: "expression", sql: expression },
-            });
-        }),
-        generatedSql: (sql) => {
-            const expression = sql.trim();
-            if (expression.length === 0 || expression !== sql) {
-                throw new TypeError("Generated SQL must be a trimmed non-empty expression");
-            }
-            if (state.defaultSpec !== undefined) {
-                throw new TypeError("A generated column cannot also have a default");
-            }
-            return createColumn(type, {
-                ...state,
-                generatedSpec: { kind: "stored", sql: expression },
-            });
-        },
-        autoIncrement: (() => {
-            if (type !== "number") {
-                throw new TypeError("Auto-increment requires a number column");
-            }
-            return createColumn(type, {
-                ...state,
-                defaultSpec: { kind: "autoincrement" },
-            });
-        }),
-    };
+function foreignKeyName(tableName, columnName) {
+  return `${tableName}_${columnName}_fkey`;
 }
-function validateSchemaName(name, kind) {
-    if (name.length === 0)
-        throw new TypeError(`${kind} name cannot be empty`);
-    if (name.trim() !== name) {
-        throw new TypeError(`${kind} name cannot start or end with whitespace: ${JSON.stringify(name)}`);
+function defaultSpecFromArg(type, value, sqlDomain) {
+  if (sqlDomain?.kind === "numeric") {
+    if ((typeof value !== "number" || !Number.isFinite(value)) && typeof value !== "string") {
+      throw new TypeError("NUMERIC default must be a finite number or decimal string");
     }
+    normalizeSqlDomainValue(sqlDomain, value);
+    return { kind: "literal", value };
+  }
+  switch (type) {
+    case "datetime":
+      if (!(value instanceof Date) || !Number.isFinite(dateMilliseconds(value))) {
+        throw new TypeError("Default literal must be a valid Date");
+      }
+      return { kind: "literal", value: copyDate(value) };
+    case "string":
+      if (typeof value !== "string")
+        throw new TypeError("Default literal must be a string");
+      return { kind: "literal", value };
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError("Default literal must be a finite number");
+      }
+      return { kind: "literal", value };
+    case "boolean":
+      if (typeof value !== "boolean")
+        throw new TypeError("Default literal must be a boolean");
+      return { kind: "literal", value };
+  }
 }
-/** Rebuilds a fluent column from structured-clone-safe metadata. */
-export function columnFromState(state) {
-    return createColumn(state.type, {
-        isNullable: state.isNullable,
-        isUnique: state.isUnique,
-        integer: state.integer ?? false,
-        ...(state.sqlDomain === undefined ? {} : { sqlDomain: state.sqlDomain }),
-        ...(state.renamedFromName === undefined ? {} : { renamedFromName: state.renamedFromName }),
-        ...(state.reference === undefined ? {} : { reference: state.reference }),
-        ...(state.defaultSpec === undefined ? {} : { defaultSpec: state.defaultSpec }),
-        ...(state.generatedSpec === undefined ? {} : { generatedSpec: state.generatedSpec }),
-        ...(state.enumValues === undefined ? {} : { enumValues: state.enumValues }),
-        ...(state.backfillValue === undefined ? {} : { backfillValue: state.backfillValue }),
-    });
-}
-export const column = {
-    boolean: () => createColumn("boolean"),
-    number: () => createColumn("number"),
-    /** Exact safe-integer semantics, matching SQL INTEGER/SMALLINT/BIGINT. */
-    integer: () => createColumn("number", { integer: true }),
-    string: () => createColumn("string"),
-    datetime: () => createColumn("datetime"),
-    /** Exact decimal SQL NUMERIC. Selects return strings; writes accept strings or numbers. */
-    numeric: (options = {}) => {
-        const sqlDomain = validateSqlDomain({ kind: "numeric", ...options }, "numeric column");
-        return createColumn("string", { sqlDomain });
-    },
-    /**
-     * JSON text at the JavaScript boundary. Optionally declare the document's shape —
-     * `column.json<{ name: string }>()` — for adapters to type `->`/`->>` traversal; the runtime
-     * value stays JSON text either way.
-     */
-    json: () => createColumn("string", {
-        sqlDomain: { kind: "json" },
+function createColumn(type, state = {}) {
+  const base = {
+    kind: "column",
+    type,
+    isNullable: state.isNullable ?? false,
+    isUnique: state.isUnique ?? false,
+    hasDefault: state.defaultSpec !== void 0,
+    isGenerated: state.generatedSpec !== void 0,
+    integer: state.integer ?? false,
+    ...state.sqlDomain === void 0 ? {} : { sqlDomain: state.sqlDomain },
+    ...state.defaultSpec === void 0 ? {} : { defaultSpec: state.defaultSpec },
+    ...state.generatedSpec === void 0 ? {} : { generatedSpec: state.generatedSpec },
+    ...state.renamedFromName === void 0 ? {} : { renamedFromName: state.renamedFromName },
+    ...state.reference === void 0 ? {} : { reference: state.reference },
+    ...state.enumValues === void 0 ? {} : { enumValues: state.enumValues },
+    ...state.backfillValue === void 0 ? {} : { backfillValue: state.backfillValue }
+  };
+  return {
+    ...base,
+    nullable: () => createColumn(type, {
+      ...state,
+      isNullable: true
     }),
-    jsonb: () => createColumn("string", {
-        sqlDomain: { kind: "jsonb" },
+    unique: () => createColumn(type, {
+      ...state,
+      isUnique: true
+    }),
+    renamedFrom: (name) => {
+      validateSchemaName(name, "Rename source");
+      return createColumn(type, {
+        ...state,
+        renamedFromName: name
+      });
+    },
+    backfill: (value) => createColumn(type, {
+      ...state,
+      backfillValue: value
     }),
-    uuid: () => createColumn("string", { sqlDomain: { kind: "uuid" } }),
-    /** A zoneless calendar date, represented publicly as canonical `YYYY-MM-DD` text. */
-    date: () => createColumn("string", { sqlDomain: { kind: "date" } }),
-    time: () => createColumn("string", { sqlDomain: { kind: "time" } }),
-    interval: () => createColumn("string", {
-        sqlDomain: { kind: "interval" },
+    references: (table2, referencedColumn, options = {}) => {
+      validateSchemaName(table2, "Referenced table");
+      validateSchemaName(referencedColumn, "Referenced column");
+      if (options.enforced === false && options.onDelete !== void 0) {
+        throw new TypeError("An informational FOREIGN KEY cannot declare ON DELETE behavior");
+      }
+      return createColumn(type, {
+        ...state,
+        reference: {
+          table: table2,
+          column: referencedColumn,
+          onDelete: options.onDelete ?? "restrict",
+          enforced: options.enforced !== false
+        }
+      });
+    },
+    default: ((value) => {
+      return createColumn(type, {
+        ...state,
+        defaultSpec: defaultSpecFromArg(type, value, state.sqlDomain)
+      });
     }),
-    /** JSON array text at the JavaScript boundary, with the SQL element type retained in metadata. */
-    array: (element) => createColumn("string", {
-        sqlDomain: validateSqlDomain({ kind: "array", element }, "array column"),
+    defaultSql: ((sql) => {
+      const expression = sql.trim();
+      if (expression.length === 0 || expression !== sql) {
+        throw new TypeError("Default SQL must be a trimmed non-empty expression");
+      }
+      return createColumn(type, {
+        ...state,
+        defaultSpec: { kind: "expression", sql: expression }
+      });
     }),
-    /** A named SQL enum domain, distinct from the lightweight `column.enum()` restriction. */
-    sqlEnum: (name, values) => {
-        validateSchemaName(name, "Enum type");
-        return createColumn("string", {
-            sqlDomain: validateSqlDomain({ kind: "enum", name, values: validateEnumValues(values, name) }, name),
-        });
+    generatedSql: (sql) => {
+      const expression = sql.trim();
+      if (expression.length === 0 || expression !== sql) {
+        throw new TypeError("Generated SQL must be a trimmed non-empty expression");
+      }
+      if (state.defaultSpec !== void 0) {
+        throw new TypeError("A generated column cannot also have a default");
+      }
+      return createColumn(type, {
+        ...state,
+        generatedSpec: { kind: "stored", sql: expression }
+      });
     },
-    /**
-     * A string column restricted to a closed set of values, typed as their literal union:
-     *
-     * ```ts
-     * status: column.enum(["draft", "published", "archived"]).default("draft")
-     * ```
-     *
-     * Selects return `"draft" | "published" | "archived"` and inserts accept nothing else; every
-     * write path also validates membership at runtime. Physically the column is a plain string
-     * column, so migrations may add values or relax the column to `column.string()`, but never
-     * remove values — existing rows could already hold them.
-     */
-    enum: (values) => createColumn("string", { enumValues: validateEnumValues(values, "enum column") }),
+    autoIncrement: (() => {
+      if (type !== "number") {
+        throw new TypeError("Auto-increment requires a number column");
+      }
+      return createColumn(type, {
+        ...state,
+        defaultSpec: { kind: "autoincrement" }
+      });
+    })
+  };
+}
+function validateSchemaName(name, kind) {
+  if (name.length === 0)
+    throw new TypeError(`${kind} name cannot be empty`);
+  if (name.trim() !== name) {
+    throw new TypeError(`${kind} name cannot start or end with whitespace: ${JSON.stringify(name)}`);
+  }
+}
+function columnFromState(state) {
+  return createColumn(state.type, {
+    isNullable: state.isNullable,
+    isUnique: state.isUnique,
+    integer: state.integer ?? false,
+    ...state.sqlDomain === void 0 ? {} : { sqlDomain: state.sqlDomain },
+    ...state.renamedFromName === void 0 ? {} : { renamedFromName: state.renamedFromName },
+    ...state.reference === void 0 ? {} : { reference: state.reference },
+    ...state.defaultSpec === void 0 ? {} : { defaultSpec: state.defaultSpec },
+    ...state.generatedSpec === void 0 ? {} : { generatedSpec: state.generatedSpec },
+    ...state.enumValues === void 0 ? {} : { enumValues: state.enumValues },
+    ...state.backfillValue === void 0 ? {} : { backfillValue: state.backfillValue }
+  });
+}
+const column = {
+  boolean: () => createColumn("boolean"),
+  number: () => createColumn("number"),
+  integer: () => createColumn("number", { integer: true }),
+  string: () => createColumn("string"),
+  datetime: () => createColumn("datetime"),
+  numeric: (options = {}) => {
+    const sqlDomain = validateSqlDomain({ kind: "numeric", ...options }, "numeric column");
+    return createColumn("string", { sqlDomain });
+  },
+  json: () => createColumn("string", {
+    sqlDomain: { kind: "json" }
+  }),
+  jsonb: () => createColumn("string", {
+    sqlDomain: { kind: "jsonb" }
+  }),
+  uuid: () => createColumn("string", { sqlDomain: { kind: "uuid" } }),
+  date: () => createColumn("string", { sqlDomain: { kind: "date" } }),
+  time: () => createColumn("string", { sqlDomain: { kind: "time" } }),
+  interval: () => createColumn("string", {
+    sqlDomain: { kind: "interval" }
+  }),
+  array: (element) => createColumn("string", {
+    sqlDomain: validateSqlDomain({ kind: "array", element }, "array column")
+  }),
+  sqlEnum: (name, values) => {
+    validateSchemaName(name, "Enum type");
+    return createColumn("string", {
+      sqlDomain: validateSqlDomain({ kind: "enum", name, values: validateEnumValues(values, name) }, name)
+    });
+  },
+  enum: (values) => createColumn("string", { enumValues: validateEnumValues(values, "enum column") })
 };
 function validateDeclaredColumnValue(definition, value, context, label) {
-    if (definition.sqlDomain !== undefined) {
-        try {
-            normalizeSqlDomainValue(definition.sqlDomain, value);
-        }
-        catch (error) {
-            throw new TypeError(`${label} does not fit ${context}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-        }
-        return;
-    }
-    const matches = definition.type === "datetime"
-        ? value instanceof Date && Number.isFinite(dateMilliseconds(value))
-        : definition.type === "number"
-            ? typeof value === "number" &&
-                Number.isFinite(value) &&
-                (!definition.integer || Number.isSafeInteger(value))
-            : typeof value === definition.type;
-    if (!matches) {
-        const expected = definition.integer ? "safe integer" : definition.type;
-        throw new TypeError(`${label} value must be a ${expected}: ${context}`);
-    }
-    if (definition.enumValues !== undefined &&
-        typeof value === "string" &&
-        !definition.enumValues.includes(value)) {
-        throw new TypeError(`${label} value must be one of: ${definition.enumValues.join(", ")} (${context})`);
+  if (definition.sqlDomain !== void 0) {
+    try {
+      normalizeSqlDomainValue(definition.sqlDomain, value);
+    } catch (error) {
+      throw new TypeError(`${label} does not fit ${context}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
+    return;
+  }
+  const matches = definition.type === "datetime" ? value instanceof Date && Number.isFinite(dateMilliseconds(value)) : definition.type === "number" ? typeof value === "number" && Number.isFinite(value) && (!definition.integer || Number.isSafeInteger(value)) : typeof value === definition.type;
+  if (!matches) {
+    const expected = definition.integer ? "safe integer" : definition.type;
+    throw new TypeError(`${label} value must be a ${expected}: ${context}`);
+  }
+  if (definition.enumValues !== void 0 && typeof value === "string" && !definition.enumValues.includes(value)) {
+    throw new TypeError(`${label} value must be one of: ${definition.enumValues.join(", ")} (${context})`);
+  }
 }
-export function table(name, columns, options = {}) {
-    validateSchemaName(name, "Table");
-    const entries = Object.entries(columns);
-    if (entries.length === 0)
-        throw new TypeError(`Table ${name} needs at least one column`);
-    const uniqueColumns = entries.filter(([, definition]) => definition.isUnique);
-    if (uniqueColumns.length > 1) {
-        throw new TypeError(`Table ${name} may name at most one unique column`);
-    }
-    const uniqueEntry = uniqueColumns[0];
-    const primaryKey = options.primaryKey ?? [];
-    if (uniqueEntry !== undefined && primaryKey.length > 0) {
-        throw new TypeError(`Table ${name} cannot declare both .unique() and a table primary key`);
-    }
-    if (primaryKey.length === 0 && options.primaryKey !== undefined) {
-        throw new TypeError(`Table ${name} primary key needs at least one column`);
-    }
-    if (new Set(primaryKey).size !== primaryKey.length) {
-        throw new TypeError(`Table ${name} primary key columns must be distinct`);
-    }
-    for (const columnName of primaryKey) {
-        const definition = columns[columnName];
-        if (definition === undefined) {
-            throw new TypeError(`PRIMARY KEY column not found: ${name}.${columnName}`);
-        }
-        if (definition.isNullable) {
-            throw new TypeError(`PRIMARY KEY cannot be nullable: ${name}.${columnName}`);
-        }
+function table(name, columns, options = {}) {
+  validateSchemaName(name, "Table");
+  const entries = Object.entries(columns);
+  if (entries.length === 0)
+    throw new TypeError(`Table ${name} needs at least one column`);
+  const uniqueColumns = entries.filter(([, definition]) => definition.isUnique);
+  if (uniqueColumns.length > 1) {
+    throw new TypeError(`Table ${name} may name at most one unique column`);
+  }
+  const uniqueEntry = uniqueColumns[0];
+  const primaryKey = options.primaryKey ?? [];
+  if (uniqueEntry !== void 0 && primaryKey.length > 0) {
+    throw new TypeError(`Table ${name} cannot declare both .unique() and a table primary key`);
+  }
+  if (primaryKey.length === 0 && options.primaryKey !== void 0) {
+    throw new TypeError(`Table ${name} primary key needs at least one column`);
+  }
+  if (new Set(primaryKey).size !== primaryKey.length) {
+    throw new TypeError(`Table ${name} primary key columns must be distinct`);
+  }
+  for (const columnName of primaryKey) {
+    const definition = columns[columnName];
+    if (definition === void 0) {
+      throw new TypeError(`PRIMARY KEY column not found: ${name}.${columnName}`);
     }
-    if (uniqueEntry?.[1].isNullable === true) {
-        throw new TypeError(`Table ${name} unique column must not be nullable: ${uniqueEntry[0]}`);
-    }
-    const generatedColumns = entries.map(([columnName, definition]) => ({
-        name: columnName,
-        ...(definition.generatedSpec === undefined ? {} : { generatedValue: definition.generatedSpec }),
-    }));
-    for (const [columnName, definition] of entries) {
-        validateSchemaName(columnName, "Column");
-        if (definition.integer && definition.type !== "number") {
-            throw new TypeError(`Integer domain requires a number column: ${name}.${columnName}`);
-        }
-        if (definition.sqlDomain !== undefined) {
-            if (definition.type !== "string") {
-                throw new TypeError(`SQL domains require string storage: ${name}.${columnName}`);
-            }
-            validateSqlDomain(definition.sqlDomain, `${name}.${columnName}`);
-        }
-        if (definition.integer && definition.sqlDomain !== undefined) {
-            throw new TypeError(`A column cannot be both integer and a SQL domain: ${name}.${columnName}`);
-        }
-        if (definition.enumValues !== undefined && definition.sqlDomain !== undefined) {
-            throw new TypeError(`A column cannot have both enum restrictions and a SQL domain: ${name}.${columnName}`);
-        }
-        const backfill = definition.backfillValue;
-        if (backfill !== undefined && typeof backfill !== "function") {
-            validateDeclaredColumnValue(definition, backfill, `${name}.${columnName}`, "Backfill");
-        }
-        if (backfill !== undefined && definition.isNullable) {
-            throw new TypeError(`A nullable column needs no backfill: ${name}.${columnName}. Rows without it already read NULL.`);
-        }
-        if (definition.generatedSpec !== undefined) {
-            if (definition.defaultSpec !== undefined || backfill !== undefined) {
-                throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${columnName}`);
+    if (definition.isNullable) {
+      throw new TypeError(`PRIMARY KEY cannot be nullable: ${name}.${columnName}`);
+    }
+  }
+  if (uniqueEntry?.[1].isNullable === true) {
+    throw new TypeError(`Table ${name} unique column must not be nullable: ${uniqueEntry[0]}`);
+  }
+  const generatedColumns = entries.map(([columnName, definition]) => ({
+    name: columnName,
+    ...definition.generatedSpec === void 0 ? {} : { generatedValue: definition.generatedSpec }
+  }));
+  for (const [columnName, definition] of entries) {
+    validateSchemaName(columnName, "Column");
+    if (definition.integer && definition.type !== "number") {
+      throw new TypeError(`Integer domain requires a number column: ${name}.${columnName}`);
+    }
+    if (definition.sqlDomain !== void 0) {
+      if (definition.type !== "string") {
+        throw new TypeError(`SQL domains require string storage: ${name}.${columnName}`);
+      }
+      validateSqlDomain(definition.sqlDomain, `${name}.${columnName}`);
+    }
+    if (definition.integer && definition.sqlDomain !== void 0) {
+      throw new TypeError(`A column cannot be both integer and a SQL domain: ${name}.${columnName}`);
+    }
+    if (definition.enumValues !== void 0 && definition.sqlDomain !== void 0) {
+      throw new TypeError(`A column cannot have both enum restrictions and a SQL domain: ${name}.${columnName}`);
+    }
+    const backfill = definition.backfillValue;
+    if (backfill !== void 0 && typeof backfill !== "function") {
+      validateDeclaredColumnValue(definition, backfill, `${name}.${columnName}`, "Backfill");
+    }
+    if (backfill !== void 0 && definition.isNullable) {
+      throw new TypeError(`A nullable column needs no backfill: ${name}.${columnName}. Rows without it already read NULL.`);
+    }
+    if (definition.generatedSpec !== void 0) {
+      if (definition.defaultSpec !== void 0 || backfill !== void 0) {
+        throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${columnName}`);
+      }
+      compileGeneratedColumnExpression(name, columnName, definition.generatedSpec.sql, generatedColumns);
+      if (definition.isUnique || primaryKey.includes(columnName)) {
+        throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${columnName}`);
+      }
+    }
+    if (definition.reference?.onDelete === "set null" && !definition.isNullable) {
+      throw new TypeError(`ON DELETE SET NULL requires a nullable column: ${name}.${columnName}`);
+    }
+    const spec = definition.defaultSpec;
+    if (spec === void 0)
+      continue;
+    validateColumnDefault({
+      name: columnName,
+      type: definition.type,
+      ...definition.integer ? { integer: true } : {},
+      ...definition.sqlDomain === void 0 ? {} : { sqlDomain: definition.sqlDomain },
+      nullable: definition.isNullable,
+      isUniqueKey: definition.isUnique || primaryKey.length === 1 && primaryKey[0] === columnName,
+      ...definition.enumValues === void 0 ? {} : { enumValues: definition.enumValues }
+    }, spec);
+    if (spec.kind === "expression") {
+      validateDefaultExpression(spec.sql, {
+        name: `${name}.${columnName}`,
+        type: definition.type,
+        ...definition.sqlDomain === void 0 ? {} : { sqlDomain: definition.sqlDomain }
+      });
+    }
+    if (spec.kind === "literal" && definition.sqlDomain !== void 0) {
+      normalizeSqlDomainValue(definition.sqlDomain, spec.value);
+    }
+  }
+  const foreignKeys = options.foreignKeys ?? [];
+  const constraintNames = /* @__PURE__ */ new Set();
+  const foreignKeyNames = /* @__PURE__ */ new Set();
+  for (const key of foreignKeys) {
+    validateSchemaName(key.name, "FOREIGN KEY");
+    if (key.enforced === false && key.onDelete !== void 0) {
+      throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE behavior`);
+    }
+    if (foreignKeyNames.has(key.name)) {
+      throw new TypeError(`Duplicate FOREIGN KEY in table ${name}: ${key.name}`);
+    }
+    foreignKeyNames.add(key.name);
+    if (constraintNames.has(key.name)) {
+      throw new TypeError(`Duplicate constraint in table ${name}: ${key.name}`);
+    }
+    constraintNames.add(key.name);
+    if (key.columns.length === 0 || new Set(key.columns).size !== key.columns.length) {
+      throw new TypeError(`FOREIGN KEY ${key.name} needs distinct child columns`);
+    }
+    if (key.references.columns.length === 0 || new Set(key.references.columns).size !== key.references.columns.length) {
+      throw new TypeError(`FOREIGN KEY ${key.name} needs distinct parent columns`);
+    }
+    if (key.columns.length !== key.references.columns.length) {
+      throw new TypeError(`FOREIGN KEY ${key.name} has different child and parent arity`);
+    }
+    validateSchemaName(key.references.table, "Referenced table");
+    key.references.columns.forEach((columnName) => validateSchemaName(columnName, "Referenced column"));
+    for (const columnName of key.columns) {
+      const definition = columns[columnName];
+      if (definition === void 0) {
+        throw new TypeError(`FOREIGN KEY ${key.name} names an unknown column: ${name}.${columnName}`);
+      }
+      if ((key.onDelete ?? "restrict") === "set null" && !definition.isNullable) {
+        throw new TypeError(`FOREIGN KEY ${key.name} cannot SET NULL a NOT NULL column`);
+      }
+    }
+  }
+  const checks = options.checks ?? [];
+  const checkNames = /* @__PURE__ */ new Set();
+  for (const check of checks) {
+    validateSchemaName(check.name, "CHECK");
+    if (checkNames.has(check.name)) {
+      throw new TypeError(`Duplicate CHECK in table ${name}: ${check.name}`);
+    }
+    checkNames.add(check.name);
+    if (constraintNames.has(check.name)) {
+      throw new TypeError(`Duplicate constraint in table ${name}: ${check.name}`);
+    }
+    constraintNames.add(check.name);
+    if (check.sql.trim().length === 0) {
+      throw new TypeError(`CHECK ${check.name} in table ${name} has no expression`);
+    }
+    for (const reference of expressionColumns(compileCheckExpression(check.sql, check.name))) {
+      const pieces = reference.split(".");
+      const columnName = pieces.at(-1) ?? reference;
+      const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : void 0;
+      if (qualifier !== void 0 && qualifier !== name) {
+        throw new TypeError(`CHECK ${check.name} references another table: ${reference}`);
+      }
+      if (columns[columnName] === void 0) {
+        throw new TypeError(`CHECK ${check.name} names an unknown column: ${columnName}`);
+      }
+    }
+  }
+  return {
+    kind: "table",
+    name,
+    columns,
+    primaryKey,
+    foreignKeys,
+    checks,
+    "~standard": {
+      version: 1,
+      vendor: "minnow",
+      validate(value) {
+        if (typeof value !== "object" || value === null) {
+          return { issues: [{ message: "A row must be an object", path: [] }] };
+        }
+        const row = value;
+        const issues = [];
+        for (const [columnName, definition] of entries) {
+          const columnValue = row[columnName];
+          if (columnValue === void 0) {
+            if (!definition.isNullable && definition.defaultSpec === void 0) {
+              issues.push({ message: `Missing non-nullable column`, path: [columnName] });
             }
-            compileGeneratedColumnExpression(name, columnName, definition.generatedSpec.sql, generatedColumns);
-            if (definition.isUnique || primaryKey.includes(columnName)) {
-                throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${columnName}`);
+            continue;
+          }
+          if (columnValue === null) {
+            if (!definition.isNullable) {
+              issues.push({ message: `Expected non-null value`, path: [columnName] });
             }
-        }
-        if (definition.reference?.onDelete === "set null" && !definition.isNullable) {
-            throw new TypeError(`ON DELETE SET NULL requires a nullable column: ${name}.${columnName}`);
-        }
-        const spec = definition.defaultSpec;
-        if (spec === undefined)
             continue;
-        validateColumnDefault({
-            name: columnName,
-            type: definition.type,
-            ...(definition.integer ? { integer: true } : {}),
-            ...(definition.sqlDomain === undefined ? {} : { sqlDomain: definition.sqlDomain }),
-            nullable: definition.isNullable,
-            isUniqueKey: definition.isUnique || (primaryKey.length === 1 && primaryKey[0] === columnName),
-            ...(definition.enumValues === undefined ? {} : { enumValues: definition.enumValues }),
-        }, spec);
-        if (spec.kind === "expression") {
-            validateDefaultExpression(spec.sql, {
-                name: `${name}.${columnName}`,
-                type: definition.type,
-                ...(definition.sqlDomain === undefined ? {} : { sqlDomain: definition.sqlDomain }),
+          }
+          try {
+            validateDeclaredColumnValue(definition, columnValue, `${name}.${columnName}`, "Value");
+          } catch (error) {
+            const message = definition.enumValues !== void 0 && typeof columnValue === "string" ? `Expected one of: ${definition.enumValues.join(", ")}` : definition.sqlDomain === void 0 ? `Expected ${definition.integer ? "safe integer" : definition.type}` : error instanceof Error ? error.message : `Invalid value`;
+            issues.push({
+              message,
+              path: [columnName]
             });
+          }
         }
-        if (spec.kind === "literal" && definition.sqlDomain !== undefined) {
-            normalizeSqlDomainValue(definition.sqlDomain, spec.value);
-        }
-    }
-    const foreignKeys = options.foreignKeys ?? [];
-    const constraintNames = new Set();
-    const foreignKeyNames = new Set();
-    for (const key of foreignKeys) {
-        validateSchemaName(key.name, "FOREIGN KEY");
-        if (key.enforced === false && key.onDelete !== undefined) {
-            throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE behavior`);
-        }
-        if (foreignKeyNames.has(key.name)) {
-            throw new TypeError(`Duplicate FOREIGN KEY in table ${name}: ${key.name}`);
-        }
-        foreignKeyNames.add(key.name);
-        if (constraintNames.has(key.name)) {
-            throw new TypeError(`Duplicate constraint in table ${name}: ${key.name}`);
-        }
-        constraintNames.add(key.name);
-        if (key.columns.length === 0 || new Set(key.columns).size !== key.columns.length) {
-            throw new TypeError(`FOREIGN KEY ${key.name} needs distinct child columns`);
-        }
-        if (key.references.columns.length === 0 ||
-            new Set(key.references.columns).size !== key.references.columns.length) {
-            throw new TypeError(`FOREIGN KEY ${key.name} needs distinct parent columns`);
-        }
-        if (key.columns.length !== key.references.columns.length) {
-            throw new TypeError(`FOREIGN KEY ${key.name} has different child and parent arity`);
-        }
-        validateSchemaName(key.references.table, "Referenced table");
-        key.references.columns.forEach((columnName) => validateSchemaName(columnName, "Referenced column"));
-        for (const columnName of key.columns) {
-            const definition = columns[columnName];
-            if (definition === undefined) {
-                throw new TypeError(`FOREIGN KEY ${key.name} names an unknown column: ${name}.${columnName}`);
-            }
-            if ((key.onDelete ?? "restrict") === "set null" && !definition.isNullable) {
-                throw new TypeError(`FOREIGN KEY ${key.name} cannot SET NULL a NOT NULL column`);
-            }
-        }
-    }
-    const checks = options.checks ?? [];
-    const checkNames = new Set();
-    for (const check of checks) {
-        validateSchemaName(check.name, "CHECK");
-        if (checkNames.has(check.name)) {
-            throw new TypeError(`Duplicate CHECK in table ${name}: ${check.name}`);
-        }
-        checkNames.add(check.name);
-        if (constraintNames.has(check.name)) {
-            throw new TypeError(`Duplicate constraint in table ${name}: ${check.name}`);
-        }
-        constraintNames.add(check.name);
-        if (check.sql.trim().length === 0) {
-            throw new TypeError(`CHECK ${check.name} in table ${name} has no expression`);
-        }
-        for (const reference of expressionColumns(compileCheckExpression(check.sql, check.name))) {
-            const pieces = reference.split(".");
-            const columnName = pieces.at(-1) ?? reference;
-            const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : undefined;
-            if (qualifier !== undefined && qualifier !== name) {
-                throw new TypeError(`CHECK ${check.name} references another table: ${reference}`);
-            }
-            if (columns[columnName] === undefined) {
-                throw new TypeError(`CHECK ${check.name} names an unknown column: ${columnName}`);
-            }
+        for (const key of Object.keys(row)) {
+          if (!(key in columns))
+            issues.push({ message: "Unknown column", path: [key] });
         }
+        return issues.length > 0 ? { issues } : { value: row };
+      }
     }
-    return {
-        kind: "table",
-        name,
-        columns,
-        primaryKey,
-        foreignKeys,
-        checks,
-        "~standard": {
-            version: 1,
-            vendor: "minnow",
-            validate(value) {
-                if (typeof value !== "object" || value === null) {
-                    return { issues: [{ message: "A row must be an object", path: [] }] };
-                }
-                const row = value;
-                const issues = [];
-                for (const [columnName, definition] of entries) {
-                    const columnValue = row[columnName];
-                    if (columnValue === undefined) {
-                        if (!definition.isNullable && definition.defaultSpec === undefined) {
-                            issues.push({ message: `Missing non-nullable column`, path: [columnName] });
-                        }
-                        continue;
-                    }
-                    if (columnValue === null) {
-                        if (!definition.isNullable) {
-                            issues.push({ message: `Expected non-null value`, path: [columnName] });
-                        }
-                        continue;
-                    }
-                    try {
-                        validateDeclaredColumnValue(definition, columnValue, `${name}.${columnName}`, "Value");
-                    }
-                    catch (error) {
-                        const message = definition.enumValues !== undefined && typeof columnValue === "string"
-                            ? `Expected one of: ${definition.enumValues.join(", ")}`
-                            : definition.sqlDomain === undefined
-                                ? `Expected ${definition.integer ? "safe integer" : definition.type}`
-                                : error instanceof Error
-                                    ? error.message
-                                    : `Invalid value`;
-                        issues.push({
-                            message,
-                            path: [columnName],
-                        });
-                    }
-                }
-                for (const key of Object.keys(row)) {
-                    if (!(key in columns))
-                        issues.push({ message: "Unknown column", path: [key] });
-                }
-                return issues.length > 0 ? { issues } : { value: row };
-            },
-        },
-    };
+  };
 }
-/**
- * The FOREIGN KEY constraints a table declares, in column order. This is the single derivation
- * of "what relations does this table have" — `planMigration` diffs against it and `migrate()`
- * creates from it, so the two can never disagree.
- */
-export function declaredForeignKeys(definition) {
-    const keys = [];
-    for (const [columnName, columnDefinition] of Object.entries(definition.columns)) {
-        const reference = columnDefinition.reference;
-        if (reference === undefined)
-            continue;
-        keys.push({
-            name: foreignKeyName(definition.name, columnName),
-            columns: [columnName],
-            parentTable: reference.table,
-            parentColumns: [reference.column],
-            onDelete: reference.onDelete,
-            enforced: reference.enforced,
-        });
+function declaredForeignKeys(definition) {
+  const keys = [];
+  for (const [columnName, columnDefinition] of Object.entries(definition.columns)) {
+    const reference = columnDefinition.reference;
+    if (reference === void 0)
+      continue;
+    keys.push({
+      name: foreignKeyName(definition.name, columnName),
+      columns: [columnName],
+      parentTable: reference.table,
+      parentColumns: [reference.column],
+      onDelete: reference.onDelete,
+      enforced: reference.enforced
+    });
+  }
+  for (const key of definition.foreignKeys) {
+    const childColumns = [...key.columns];
+    const parentColumns = [...key.references.columns];
+    keys.push({
+      name: key.name,
+      columns: childColumns,
+      parentTable: key.references.table,
+      parentColumns,
+      onDelete: key.onDelete ?? "restrict",
+      enforced: key.enforced !== false
+    });
+  }
+  return keys;
+}
+function view(name, definition) {
+  validateSchemaName(name, "View");
+  const entries = Object.entries(definition.columns);
+  if (entries.length === 0)
+    throw new TypeError(`View ${name} needs at least one column`);
+  if (definition.sql.trim().length === 0)
+    throw new TypeError(`View ${name} has no query`);
+  for (const [columnName, columnDefinition] of entries) {
+    validateSchemaName(columnName, "Column");
+    if (columnDefinition.isUnique) {
+      throw new TypeError(`A view column cannot be a unique key: ${name}.${columnName}`);
     }
-    for (const key of definition.foreignKeys) {
-        const childColumns = [...key.columns];
-        const parentColumns = [...key.references.columns];
-        keys.push({
-            name: key.name,
-            columns: childColumns,
-            parentTable: key.references.table,
-            parentColumns,
-            onDelete: key.onDelete ?? "restrict",
-            enforced: key.enforced !== false,
-        });
+    if (columnDefinition.defaultSpec !== void 0) {
+      throw new TypeError(`A view column cannot have a default: ${name}.${columnName}`);
     }
-    return keys;
-}
-/**
- * Declares a view. Its columns use the same builders tables use, so a view row types exactly like
- * a table row — but a view is read-only, and the typed facade will not let a write name one.
- *
- * ```ts
- * const activeCustomers = view("active_customers", {
- *   sql: `SELECT customer_id, name FROM customers WHERE status = 'active'`,
- *   columns: { customer_id: column.number(), name: column.string() },
- * });
- * ```
- */
-export function view(name, definition) {
-    validateSchemaName(name, "View");
-    const entries = Object.entries(definition.columns);
-    if (entries.length === 0)
-        throw new TypeError(`View ${name} needs at least one column`);
-    if (definition.sql.trim().length === 0)
-        throw new TypeError(`View ${name} has no query`);
-    for (const [columnName, columnDefinition] of entries) {
-        validateSchemaName(columnName, "Column");
-        if (columnDefinition.isUnique) {
-            throw new TypeError(`A view column cannot be a unique key: ${name}.${columnName}`);
-        }
-        if (columnDefinition.defaultSpec !== undefined) {
-            throw new TypeError(`A view column cannot have a default: ${name}.${columnName}`);
-        }
-        if (columnDefinition.generatedSpec !== undefined) {
-            throw new TypeError(`A view column cannot be generated: ${name}.${columnName}`);
-        }
+    if (columnDefinition.generatedSpec !== void 0) {
+      throw new TypeError(`A view column cannot be generated: ${name}.${columnName}`);
     }
-    return { kind: "view", name, sql: definition.sql, columns: definition.columns };
+  }
+  return { kind: "view", name, sql: definition.sql, columns: definition.columns };
 }
-export function schema(tables, options = {}) {
-    const views = (options.views ?? []);
-    const names = new Set();
-    for (const definition of tables) {
-        if (names.has(definition.name)) {
-            throw new TypeError(`Duplicate table in schema: ${definition.name}`);
-        }
-        names.add(definition.name);
+function schema(tables, options = {}) {
+  const views = options.views ?? [];
+  const names = /* @__PURE__ */ new Set();
+  for (const definition of tables) {
+    if (names.has(definition.name)) {
+      throw new TypeError(`Duplicate table in schema: ${definition.name}`);
     }
-    for (const definition of views) {
-        if (names.has(definition.name)) {
-            throw new TypeError(`Duplicate name in schema: ${definition.name}`);
-        }
-        names.add(definition.name);
+    names.add(definition.name);
+  }
+  for (const definition of views) {
+    if (names.has(definition.name)) {
+      throw new TypeError(`Duplicate name in schema: ${definition.name}`);
     }
-    for (const definition of tables) {
-        const declaredNames = new Set();
-        for (const key of declaredForeignKeys(definition)) {
-            if (declaredNames.has(key.name)) {
-                throw new TypeError(`Duplicate FOREIGN KEY in table ${definition.name}: ${key.name}`);
-            }
-            declaredNames.add(key.name);
-            const childNames = key.columns;
-            const parentNames = key.parentColumns;
-            const target = tables.find(({ name }) => name === key.parentTable);
-            if (target === undefined ||
-                childNames.some((columnName) => !(columnName in definition.columns)) ||
-                parentNames.some((columnName) => !(columnName in target.columns))) {
-                throw new TypeError(`Relation target does not exist: ${definition.name}.${childNames.join(",")} -> ${key.parentTable}.${parentNames.join(",")}`);
-            }
-            const targetPrimary = target.primaryKey.length > 0
-                ? [...target.primaryKey]
-                : Object.entries(target.columns).flatMap(([name, columnDefinition]) => columnDefinition.isUnique ? [name] : []);
-            if (parentNames.length !== targetPrimary.length ||
-                parentNames.some((columnName, index) => columnName !== targetPrimary[index])) {
-                throw new TypeError(`Relation target must be the unique key: ${definition.name}.${childNames.join(",")} -> ${key.parentTable}(${targetPrimary.join(", ")})`);
-            }
-            childNames.forEach((childName, index) => {
-                const child = definition.columns[childName];
-                const parentName = parentNames[index];
-                const parent = parentName === undefined ? undefined : target.columns[parentName];
-                if (child === undefined ||
-                    child.type !== parent?.type ||
-                    child.integer !== parent.integer ||
-                    JSON.stringify(child.sqlDomain ?? null) !== JSON.stringify(parent.sqlDomain ?? null)) {
-                    throw new TypeError(`Relation types must match: ${definition.name}.${childName} and ${key.parentTable}.${String(parentName)}`);
-                }
-            });
-        }
+    names.add(definition.name);
+  }
+  for (const definition of tables) {
+    const declaredNames = /* @__PURE__ */ new Set();
+    for (const key of declaredForeignKeys(definition)) {
+      if (declaredNames.has(key.name)) {
+        throw new TypeError(`Duplicate FOREIGN KEY in table ${definition.name}: ${key.name}`);
+      }
+      declaredNames.add(key.name);
+      const childNames = key.columns;
+      const parentNames = key.parentColumns;
+      const target = tables.find(({ name }) => name === key.parentTable);
+      if (target === void 0 || childNames.some((columnName) => !(columnName in definition.columns)) || parentNames.some((columnName) => !(columnName in target.columns))) {
+        throw new TypeError(`Relation target does not exist: ${definition.name}.${childNames.join(",")} -> ${key.parentTable}.${parentNames.join(",")}`);
+      }
+      const targetPrimary = target.primaryKey.length > 0 ? [...target.primaryKey] : Object.entries(target.columns).flatMap(([name, columnDefinition]) => columnDefinition.isUnique ? [name] : []);
+      if (parentNames.length !== targetPrimary.length || parentNames.some((columnName, index) => columnName !== targetPrimary[index])) {
+        throw new TypeError(`Relation target must be the unique key: ${definition.name}.${childNames.join(",")} -> ${key.parentTable}(${targetPrimary.join(", ")})`);
+      }
+      childNames.forEach((childName, index) => {
+        const child = definition.columns[childName];
+        const parentName = parentNames[index];
+        const parent = parentName === void 0 ? void 0 : target.columns[parentName];
+        if (child === void 0 || child.type !== parent?.type || child.integer !== parent.integer || JSON.stringify(child.sqlDomain ?? null) !== JSON.stringify(parent.sqlDomain ?? null)) {
+          throw new TypeError(`Relation types must match: ${definition.name}.${childName} and ${key.parentTable}.${String(parentName)}`);
+        }
+      });
     }
-    return { kind: "schema", tables, views };
+  }
+  return { kind: "schema", tables, views };
 }
-/**
- * Views are derived: nothing is stored under one, so a body change is a replace rather than a
- * rewrite and needs none of the proofs a table alteration needs.
- *
- * Within the set of views a migration created, the schema is authoritative — removing a
- * declaration drops the view. Outside it nothing is touched: a view created with `CREATE VIEW`,
- * or one written before ownership was recorded, is not any schema's to remove. That is the
- * difference between a declaration being the source of truth and a declaration being allowed to
- * destroy things it never made.
- */
 function planViewSteps(catalog, definition, steps) {
-    const tableNames = new Set(catalog.tables.map(({ name }) => name));
-    const existing = new Map(catalog.views.map((record) => [record.name, record]));
-    const declared = new Set(definition.views.map(({ name }) => name));
-    for (const viewDefinition of definition.views) {
-        if (tableNames.has(viewDefinition.name)) {
-            throw new TypeError(`A table already exists with this name: ${viewDefinition.name}`);
-        }
-        if (existing.get(viewDefinition.name)?.sql === viewDefinition.sql)
-            continue;
-        steps.push({ kind: "replace-view", view: viewDefinition });
-    }
-    for (const record of catalog.views) {
-        if (declared.has(record.name) || !record.managed)
-            continue;
-        steps.push({ kind: "drop-view", viewName: record.name });
+  const tableNames = new Set(catalog.tables.map(({ name }) => name));
+  const existing = new Map(catalog.views.map((record) => [record.name, record]));
+  const declared = new Set(definition.views.map(({ name }) => name));
+  for (const viewDefinition of definition.views) {
+    if (tableNames.has(viewDefinition.name)) {
+      throw new TypeError(`A table already exists with this name: ${viewDefinition.name}`);
     }
+    if (existing.get(viewDefinition.name)?.sql === viewDefinition.sql)
+      continue;
+    steps.push({ kind: "replace-view", view: viewDefinition });
+  }
+  for (const record of catalog.views) {
+    if (declared.has(record.name) || !record.managed)
+      continue;
+    steps.push({ kind: "drop-view", viewName: record.name });
+  }
 }
-/**
- * Creation order, so a table is created after the tables it references. A FOREIGN KEY names a
- * parent that must already exist, which would otherwise make a schema fail purely because its
- * tables were listed child-first. Declaration order is preserved among tables that do not
- * constrain each other, and a reference cycle (or a self-reference, which the engine allows)
- * falls back to declaration order rather than failing here — the engine still has the final say.
- */
 function orderedForCreation(tables) {
-    const byName = new Map(tables.map((definition) => [definition.name, definition]));
-    const ordered = [];
-    const state = new Map();
-    const visit = (definition) => {
-        const status = state.get(definition.name);
-        if (status !== undefined)
-            return; // done, or a cycle we decline to reorder
-        state.set(definition.name, "visiting");
-        for (const key of declaredForeignKeys(definition)) {
-            const parent = byName.get(key.parentTable);
-            if (parent !== undefined && parent !== definition)
-                visit(parent);
-        }
-        state.set(definition.name, "done");
-        ordered.push(definition);
-    };
-    for (const definition of tables)
-        visit(definition);
-    return ordered;
+  const byName = new Map(tables.map((definition) => [definition.name, definition]));
+  const ordered = [];
+  const state = /* @__PURE__ */ new Map();
+  const visit = (definition) => {
+    const status = state.get(definition.name);
+    if (status !== void 0)
+      return;
+    state.set(definition.name, "visiting");
+    for (const key of declaredForeignKeys(definition)) {
+      const parent = byName.get(key.parentTable);
+      if (parent !== void 0 && parent !== definition)
+        visit(parent);
+    }
+    state.set(definition.name, "done");
+    ordered.push(definition);
+  };
+  for (const definition of tables)
+    visit(definition);
+  return ordered;
 }
-/**
- * Whether a step destroys data a reader could still see. These are the steps `migrate()` refuses
- * to apply unless the caller opts in, so that a schema file drifting out of sync cannot delete
- * rows the next time an application opens.
- */
-export function isDestructiveStep(step) {
-    return step.kind === "drop-column" || step.kind === "drop-table";
+function isDestructiveStep(step) {
+  return step.kind === "drop-column" || step.kind === "drop-table";
 }
-/**
- * A column can stop being projected without rewriting anything, but not while something else in
- * the catalog still points at it. Each of these would leave a constraint or key referring to a
- * column no longer there, so the drop is refused rather than silently invalidating them.
- */
-export function assertColumnDroppable(record, column) {
-    const where = `${record.name}.${column.name}`;
-    if (record.uniqueKeyColumnId === column.id ||
-        (record.primaryKeyColumnIds ?? []).includes(column.id)) {
-        throw new TypeError(`The unique key cannot be dropped: ${where}. Unique-key changes need the table recreated.`);
-    }
-    for (const key of record.foreignKeys) {
-        if (key.columns.includes(column.name)) {
-            throw new TypeError(`FOREIGN KEY ${key.name} still uses this column: ${where}`);
-        }
+function assertColumnDroppable(record, column2) {
+  const where = `${record.name}.${column2.name}`;
+  if (record.uniqueKeyColumnId === column2.id || (record.primaryKeyColumnIds ?? []).includes(column2.id)) {
+    throw new TypeError(`The unique key cannot be dropped: ${where}. Unique-key changes need the table recreated.`);
+  }
+  for (const key of record.foreignKeys) {
+    if (key.columns.includes(column2.name)) {
+      throw new TypeError(`FOREIGN KEY ${key.name} still uses this column: ${where}`);
     }
-    for (const index of record.indexes ?? []) {
-        if (index.columns.some(({ name }) => name === column.name)) {
-            throw new TypeError(`Index ${index.name} still uses this column: ${where}`);
-        }
+  }
+  for (const index of record.indexes ?? []) {
+    if (index.columns.some(({ name }) => name === column2.name)) {
+      throw new TypeError(`Index ${index.name} still uses this column: ${where}`);
     }
-    for (const check of record.checks) {
-        let referenced;
-        try {
-            referenced = expressionColumns(compileCheckExpression(check.sql, check.name));
-        }
-        catch {
-            // A check the engine can no longer compile is not a licence to drop what it names.
-            throw new TypeError(`CHECK ${check.name} cannot be re-read, so ${where} is not droppable`);
-        }
-        if (referenced.includes(column.name)) {
-            throw new TypeError(`CHECK ${check.name} still uses this column: ${where}`);
-        }
+  }
+  for (const check of record.checks) {
+    let referenced;
+    try {
+      referenced = expressionColumns(compileCheckExpression(check.sql, check.name));
+    } catch {
+      throw new TypeError(`CHECK ${check.name} cannot be re-read, so ${where} is not droppable`);
     }
-    for (const dependent of record.columns) {
-        if (dependent.generatedValue === undefined)
-            continue;
-        let referenced;
-        try {
-            referenced = expressionColumns(compileCheckExpression(dependent.generatedValue.sql, `generated ${record.name}.${dependent.name}`));
-        }
-        catch {
-            throw new TypeError(`Generated column ${dependent.name} cannot be re-read, so ${where} is not droppable`);
-        }
-        if (referenced.includes(column.name)) {
-            throw new TypeError(`Generated column ${dependent.name} still uses this column: ${where}`);
-        }
+    if (referenced.includes(column2.name)) {
+      throw new TypeError(`CHECK ${check.name} still uses this column: ${where}`);
+    }
+  }
+  for (const dependent of record.columns) {
+    if (dependent.generatedValue === void 0)
+      continue;
+    let referenced;
+    try {
+      referenced = expressionColumns(compileCheckExpression(dependent.generatedValue.sql, `generated ${record.name}.${dependent.name}`));
+    } catch {
+      throw new TypeError(`Generated column ${dependent.name} cannot be re-read, so ${where} is not droppable`);
     }
+    if (referenced.includes(column2.name)) {
+      throw new TypeError(`Generated column ${dependent.name} still uses this column: ${where}`);
+    }
+  }
 }
-function assertColumnRenamable(catalog, record, column) {
-    const where = `${record.name}.${column.name}`;
-    for (const owner of catalog.tables) {
-        for (const key of owner.foreignKeys) {
-            const usesChild = owner.name === record.name && key.columns.includes(column.name);
-            const usesParent = key.parentTable === record.name && key.parentColumns.includes(column.name);
-            if (usesChild || usesParent) {
-                throw new TypeError(`FOREIGN KEY ${key.name} prevents renaming ${where}`);
-            }
-        }
+function assertColumnRenamable(catalog, record, column2) {
+  const where = `${record.name}.${column2.name}`;
+  for (const owner of catalog.tables) {
+    for (const key of owner.foreignKeys) {
+      const usesChild = owner.name === record.name && key.columns.includes(column2.name);
+      const usesParent = key.parentTable === record.name && key.parentColumns.includes(column2.name);
+      if (usesChild || usesParent) {
+        throw new TypeError(`FOREIGN KEY ${key.name} prevents renaming ${where}`);
+      }
     }
-    for (const check of record.checks) {
-        const referenced = expressionColumns(compileCheckExpression(check.sql, check.name));
-        if (referenced.includes(column.name)) {
-            throw new TypeError(`CHECK ${check.name} prevents renaming ${where}`);
-        }
+  }
+  for (const check of record.checks) {
+    const referenced = expressionColumns(compileCheckExpression(check.sql, check.name));
+    if (referenced.includes(column2.name)) {
+      throw new TypeError(`CHECK ${check.name} prevents renaming ${where}`);
     }
-    for (const dependent of record.columns) {
-        if (dependent.generatedValue === undefined)
-            continue;
-        const referenced = expressionColumns(compileCheckExpression(dependent.generatedValue.sql, `generated ${record.name}.${dependent.name}`));
-        if (referenced.includes(column.name)) {
-            throw new TypeError(`Generated column ${dependent.name} prevents renaming ${where}`);
-        }
+  }
+  for (const dependent of record.columns) {
+    if (dependent.generatedValue === void 0)
+      continue;
+    const referenced = expressionColumns(compileCheckExpression(dependent.generatedValue.sql, `generated ${record.name}.${dependent.name}`));
+    if (referenced.includes(column2.name)) {
+      throw new TypeError(`Generated column ${dependent.name} prevents renaming ${where}`);
     }
+  }
 }
-/**
- * Freezes a column's backfill. A generator runs exactly once — here, while the migration is being
- * planned — so the catalog stores a value rather than a function and no two readers can disagree.
- */
 function resolveBackfill(definition) {
-    const declared = definition.backfillValue;
-    if (declared === undefined)
-        return undefined;
-    const value = typeof declared === "function" ? declared() : declared;
-    validateDeclaredColumnValue(definition, value, "added column", "Backfill");
-    return value;
+  const declared = definition.backfillValue;
+  if (declared === void 0)
+    return void 0;
+  const value = typeof declared === "function" ? declared() : declared;
+  validateDeclaredColumnValue(definition, value, "added column", "Backfill");
+  return value;
 }
 function storedBackfill(definition, value) {
-    if (definition.sqlDomain === undefined)
-        return value;
-    const normalized = normalizeSqlDomainValue(definition.sqlDomain, value);
-    if (normalized === null)
-        throw new TypeError("A backfill cannot be NULL");
-    return normalized;
+  if (definition.sqlDomain === void 0)
+    return value;
+  const normalized = normalizeSqlDomainValue(definition.sqlDomain, value);
+  if (normalized === null)
+    throw new TypeError("A backfill cannot be NULL");
+  return normalized;
 }
 function backfillsEqual(left, right) {
-    const externalLeft = externalSqlDomainValue(left);
-    const externalRight = externalSqlDomainValue(right);
-    if (externalLeft instanceof Date || externalRight instanceof Date) {
-        return (externalLeft instanceof Date &&
-            externalRight instanceof Date &&
-            dateMilliseconds(externalLeft) === dateMilliseconds(externalRight));
-    }
-    return externalLeft === externalRight;
+  const externalLeft = externalSqlDomainValue(left);
+  const externalRight = externalSqlDomainValue(right);
+  if (externalLeft instanceof Date || externalRight instanceof Date) {
+    return externalLeft instanceof Date && externalRight instanceof Date && dateMilliseconds(externalLeft) === dateMilliseconds(externalRight);
+  }
+  return externalLeft === externalRight;
 }
-/**
- * Enforced constraints on an existing table cannot change through a metadata-only step. Attaching
- * a FOREIGN KEY or CHECK to a table that already holds rows would claim something about those rows
- * that nobody has verified, and no validation scan exists; dropping one is refused for the mirror
- * reason, so that a constraint never disappears because a schema file drifted. Informational
- * foreign keys are catalog metadata only, so adding, dropping, or remapping one is safe.
- */
 function planConstraintChanges(record, definition, steps) {
-    const describeKey = (key) => `${key.columns.join(",")} -> ${key.parentTable}.` +
-        `${key.parentColumns.join(",")} ON DELETE ${key.onDelete}`;
-    const declaredList = declaredForeignKeys(definition);
-    const existingKeys = new Map(record.foreignKeys.map((key) => [key.name, key]));
-    const declaredKeys = new Map(declaredList.map((key) => [key.name, key]));
-    let informationalChanged = false;
-    for (const [name, declared] of declaredKeys) {
-        const existing = existingKeys.get(name);
-        if (existing === undefined) {
-            if (!declared.enforced) {
-                informationalChanged = true;
-                continue;
-            }
-            throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.columns.join(",")}. ` +
-                `Existing rows are not known to satisfy it; recreate the table to add a relation.`);
-        }
-        if (existing.enforced !== declared.enforced) {
-            throw new TypeError(`FOREIGN KEY enforcement cannot change: ${definition.name}.${declared.columns.join(",")}`);
-        }
-        if (describeKey(existing) !== describeKey(declared)) {
-            if (!declared.enforced) {
-                informationalChanged = true;
-                continue;
-            }
-            throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.columns.join(",")} is ` +
-                `${describeKey(existing)}, schema says ${describeKey(declared)}`);
-        }
+  const describeKey = (key) => `${key.columns.join(",")} -> ${key.parentTable}.${key.parentColumns.join(",")} ON DELETE ${key.onDelete}`;
+  const declaredList = declaredForeignKeys(definition);
+  const existingKeys = new Map(record.foreignKeys.map((key) => [key.name, key]));
+  const declaredKeys = new Map(declaredList.map((key) => [key.name, key]));
+  let informationalChanged = false;
+  for (const [name, declared] of declaredKeys) {
+    const existing = existingKeys.get(name);
+    if (existing === void 0) {
+      if (!declared.enforced) {
+        informationalChanged = true;
+        continue;
+      }
+      throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.columns.join(",")}. Existing rows are not known to satisfy it; recreate the table to add a relation.`);
     }
-    for (const name of existingKeys.keys()) {
-        if (!declaredKeys.has(name)) {
-            if (existingKeys.get(name)?.enforced === false) {
-                informationalChanged = true;
-                continue;
-            }
-            throw new TypeError(`FOREIGN KEY cannot be dropped: ${definition.name} still has ${name}. ` +
-                `Declare the relation, or recreate the table without it.`);
-        }
+    if (existing.enforced !== declared.enforced) {
+      throw new TypeError(`FOREIGN KEY enforcement cannot change: ${definition.name}.${declared.columns.join(",")}`);
     }
-    if (informationalChanged) {
-        steps.push({
-            kind: "alter-foreign-keys",
-            tableName: definition.name,
-            foreignKeys: declaredList,
-        });
+    if (describeKey(existing) !== describeKey(declared)) {
+      if (!declared.enforced) {
+        informationalChanged = true;
+        continue;
+      }
+      throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.columns.join(",")} is ${describeKey(existing)}, schema says ${describeKey(declared)}`);
     }
-    const existingChecks = new Map(record.checks.map((check) => [check.name, check.sql]));
-    const declaredChecks = new Map(definition.checks.map((check) => [check.name, check.sql]));
-    for (const [name, sql] of declaredChecks) {
-        const existing = existingChecks.get(name);
-        if (existing === undefined) {
-            throw new TypeError(`CHECK cannot be added after creation: ${definition.name}.${name}. ` +
-                `Existing rows are not known to satisfy it; recreate the table to add a constraint.`);
-        }
-        if (existing !== sql) {
-            throw new TypeError(`CHECK cannot change: ${definition.name}.${name} is (${existing}), schema says (${sql})`);
-        }
+  }
+  for (const name of existingKeys.keys()) {
+    if (!declaredKeys.has(name)) {
+      if (existingKeys.get(name)?.enforced === false) {
+        informationalChanged = true;
+        continue;
+      }
+      throw new TypeError(`FOREIGN KEY cannot be dropped: ${definition.name} still has ${name}. Declare the relation, or recreate the table without it.`);
     }
-    for (const name of existingChecks.keys()) {
-        if (!declaredChecks.has(name)) {
-            throw new TypeError(`CHECK cannot be dropped: ${definition.name} still has ${name}. ` +
-                `Declare the constraint, or recreate the table without it.`);
-        }
+  }
+  if (informationalChanged) {
+    steps.push({
+      kind: "alter-foreign-keys",
+      tableName: definition.name,
+      foreignKeys: declaredList
+    });
+  }
+  const existingChecks = new Map(record.checks.map((check) => [check.name, check.sql]));
+  const declaredChecks = new Map(definition.checks.map((check) => [check.name, check.sql]));
+  for (const [name, sql] of declaredChecks) {
+    const existing = existingChecks.get(name);
+    if (existing === void 0) {
+      throw new TypeError(`CHECK cannot be added after creation: ${definition.name}.${name}. Existing rows are not known to satisfy it; recreate the table to add a constraint.`);
+    }
+    if (existing !== sql) {
+      throw new TypeError(`CHECK cannot change: ${definition.name}.${name} is (${existing}), schema says (${sql})`);
+    }
+  }
+  for (const name of existingChecks.keys()) {
+    if (!declaredChecks.has(name)) {
+      throw new TypeError(`CHECK cannot be dropped: ${definition.name} still has ${name}. Declare the constraint, or recreate the table without it.`);
     }
+  }
 }
-export function planMigration(catalog, definition, options = {}) {
-    const steps = [];
-    const currentByName = new Map(catalog.tables.map((record) => [record.name, record]));
-    for (const tableDefinition of orderedForCreation(definition.tables)) {
-        const record = currentByName.get(tableDefinition.name);
-        if (record === undefined) {
-            steps.push({ kind: "create-table", table: tableDefinition });
-            continue;
-        }
-        const recordColumnsByName = new Map(record.columns.map((columnRecord) => [columnRecord.name, columnRecord]));
-        const definedNames = new Set(Object.keys(tableDefinition.columns));
-        const renameSources = new Set();
-        for (const [columnName, columnDefinition] of Object.entries(tableDefinition.columns)) {
-            const from = columnDefinition.renamedFromName;
-            let existing = recordColumnsByName.get(columnName);
-            if (existing === undefined && from !== undefined) {
-                const source = recordColumnsByName.get(from);
-                if (source !== undefined) {
-                    if (renameSources.has(from)) {
-                        throw new TypeError(`Rename source is used more than once: ${tableDefinition.name}.${from}`);
-                    }
-                    if (definedNames.has(from)) {
-                        throw new TypeError(`Rename source is still defined: ${tableDefinition.name}.${from}`);
-                    }
-                    assertColumnRenamable(catalog, record, source);
-                    steps.push({
-                        kind: "rename-column",
-                        tableName: tableDefinition.name,
-                        from,
-                        to: columnName,
-                    });
-                    renameSources.add(from);
-                    existing = source;
-                }
-            }
-            if (existing === undefined) {
-                if (columnDefinition.generatedSpec !== undefined) {
-                    throw new TypeError(`Generated columns cannot be added to an existing table without rewriting its rows: ${tableDefinition.name}.${columnName}`);
-                }
-                const backfill = resolveBackfill(columnDefinition);
-                if (!columnDefinition.isNullable && backfill === undefined) {
-                    throw new TypeError(`Added columns must be nullable, or carry a backfill: ${tableDefinition.name}.${columnName}`);
-                }
-                if (columnDefinition.isUnique || tableDefinition.primaryKey.includes(columnName)) {
-                    throw new TypeError(`Unique keys cannot be added after creation: ${tableDefinition.name}.${columnName}`);
-                }
-                steps.push({
-                    kind: "add-column",
-                    tableName: tableDefinition.name,
-                    columnName,
-                    definition: columnDefinition,
-                    ...(backfill === undefined ? {} : { backfill }),
-                });
-                continue;
-            }
-            if (existing.type !== columnDefinition.type) {
-                throw new TypeError(`Column types cannot change: ${tableDefinition.name}.${columnName} is ${existing.type}, schema says ${columnDefinition.type}`);
-            }
-            if ((existing.integer === true) !== columnDefinition.integer ||
-                JSON.stringify(existing.sqlDomain ?? null) !==
-                    JSON.stringify(columnDefinition.sqlDomain ?? null)) {
-                throw new TypeError(`Column domains cannot change: ${tableDefinition.name}.${columnName}`);
-            }
-            if (existing.backfill === undefined && columnDefinition.backfillValue !== undefined) {
-                throw new TypeError(`Backfills cannot be added after a column exists: ${tableDefinition.name}.${columnName}`);
-            }
-            if (existing.backfill !== undefined && columnDefinition.backfillValue === undefined) {
-                throw new TypeError(`Backfills cannot be removed: ${tableDefinition.name}.${columnName}`);
-            }
-            if (existing.backfill !== undefined &&
-                columnDefinition.backfillValue !== undefined &&
-                typeof columnDefinition.backfillValue !== "function" &&
-                !backfillsEqual(existing.backfill, columnDefinition.backfillValue)) {
-                throw new TypeError(`Backfills cannot change: ${tableDefinition.name}.${columnName}`);
-            }
-            const existingEnum = existing.enumValues;
-            const definedEnum = columnDefinition.enumValues;
-            if (definedEnum !== undefined && existingEnum === undefined) {
-                throw new TypeError(`Plain string columns cannot tighten to an enum: ${tableDefinition.name}.${columnName}. Existing rows may hold values outside the set.`);
-            }
-            if (existingEnum !== undefined) {
-                if (definedEnum === undefined) {
-                    steps.push({
-                        kind: "widen-enum",
-                        tableName: tableDefinition.name,
-                        columnName,
-                        enumValues: null,
-                    });
-                }
-                else {
-                    const removed = existingEnum.filter((value) => !definedEnum.includes(value));
-                    if (removed.length > 0) {
-                        throw new TypeError(`Enum values cannot be removed: ${tableDefinition.name}.${columnName} drops ${removed.join(", ")}`);
-                    }
-                    if (definedEnum.some((value) => !existingEnum.includes(value))) {
-                        steps.push({
-                            kind: "widen-enum",
-                            tableName: tableDefinition.name,
-                            columnName,
-                            enumValues: [...definedEnum],
-                        });
-                    }
-                }
-            }
-            const existingIsKey = record.uniqueKeyColumnId === existing.id ||
-                (record.primaryKeyColumnIds ?? []).includes(existing.id);
-            const definedIsKey = columnDefinition.isUnique || tableDefinition.primaryKey.includes(columnName);
-            if (existingIsKey !== definedIsKey) {
-                throw new TypeError(`Unique keys cannot change: ${tableDefinition.name}.${columnName}`);
-            }
-            if (existing.nullable && !columnDefinition.isNullable) {
-                steps.push({
-                    kind: "tighten-nullable",
-                    tableName: tableDefinition.name,
-                    columnName,
-                });
-            }
-            if (!existing.nullable && columnDefinition.isNullable) {
-                steps.push({
-                    kind: "widen-nullable",
-                    tableName: tableDefinition.name,
-                    columnName,
-                });
-            }
-            if (!columnDefaultsEqual(existing.defaultValue, columnDefinition.defaultSpec)) {
-                const wasAuto = existing.defaultValue?.kind === "autoincrement";
-                const isAuto = columnDefinition.defaultSpec?.kind === "autoincrement";
-                if (wasAuto !== isAuto) {
-                    // Adopting one seeds the counter past the largest key already stored; dropping one
-                    // simply stops generating. Neither rewrites a row.
-                    steps.push({
-                        kind: "set-auto-increment",
-                        tableName: tableDefinition.name,
-                        columnName,
-                        enabled: isAuto,
-                    });
-                }
-                else {
-                    steps.push({
-                        kind: "alter-default",
-                        tableName: tableDefinition.name,
-                        columnName,
-                        defaultValue: columnDefinition.defaultSpec ?? null,
-                    });
-                }
-            }
-            const existingGenerated = existing.generatedValue;
-            const definedGenerated = columnDefinition.generatedSpec;
-            if (JSON.stringify(existingGenerated ?? null) !== JSON.stringify(definedGenerated ?? null)) {
-                steps.push({
-                    kind: "alter-generated",
-                    tableName: tableDefinition.name,
-                    columnName,
-                    generatedValue: definedGenerated ?? null,
-                });
-            }
+function planMigration(catalog, definition, options = {}) {
+  const steps = [];
+  const currentByName = new Map(catalog.tables.map((record) => [record.name, record]));
+  for (const tableDefinition of orderedForCreation(definition.tables)) {
+    const record = currentByName.get(tableDefinition.name);
+    if (record === void 0) {
+      steps.push({ kind: "create-table", table: tableDefinition });
+      continue;
+    }
+    const recordColumnsByName = new Map(record.columns.map((columnRecord) => [columnRecord.name, columnRecord]));
+    const definedNames = new Set(Object.keys(tableDefinition.columns));
+    const renameSources = /* @__PURE__ */ new Set();
+    for (const [columnName, columnDefinition] of Object.entries(tableDefinition.columns)) {
+      const from = columnDefinition.renamedFromName;
+      let existing = recordColumnsByName.get(columnName);
+      if (existing === void 0 && from !== void 0) {
+        const source = recordColumnsByName.get(from);
+        if (source !== void 0) {
+          if (renameSources.has(from)) {
+            throw new TypeError(`Rename source is used more than once: ${tableDefinition.name}.${from}`);
+          }
+          if (definedNames.has(from)) {
+            throw new TypeError(`Rename source is still defined: ${tableDefinition.name}.${from}`);
+          }
+          assertColumnRenamable(catalog, record, source);
+          steps.push({
+            kind: "rename-column",
+            tableName: tableDefinition.name,
+            from,
+            to: columnName
+          });
+          renameSources.add(from);
+          existing = source;
+        }
+      }
+      if (existing === void 0) {
+        if (columnDefinition.generatedSpec !== void 0) {
+          throw new TypeError(`Generated columns cannot be added to an existing table without rewriting its rows: ${tableDefinition.name}.${columnName}`);
+        }
+        const backfill = resolveBackfill(columnDefinition);
+        if (!columnDefinition.isNullable && backfill === void 0) {
+          throw new TypeError(`Added columns must be nullable, or carry a backfill: ${tableDefinition.name}.${columnName}`);
+        }
+        if (columnDefinition.isUnique || tableDefinition.primaryKey.includes(columnName)) {
+          throw new TypeError(`Unique keys cannot be added after creation: ${tableDefinition.name}.${columnName}`);
         }
-        for (const columnRecord of record.columns) {
-            if (definedNames.has(columnRecord.name) || renameSources.has(columnRecord.name))
-                continue;
-            assertColumnDroppable(record, columnRecord);
+        steps.push({
+          kind: "add-column",
+          tableName: tableDefinition.name,
+          columnName,
+          definition: columnDefinition,
+          ...backfill === void 0 ? {} : { backfill }
+        });
+        continue;
+      }
+      if (existing.type !== columnDefinition.type) {
+        throw new TypeError(`Column types cannot change: ${tableDefinition.name}.${columnName} is ${existing.type}, schema says ${columnDefinition.type}`);
+      }
+      if (existing.integer === true !== columnDefinition.integer || JSON.stringify(existing.sqlDomain ?? null) !== JSON.stringify(columnDefinition.sqlDomain ?? null)) {
+        throw new TypeError(`Column domains cannot change: ${tableDefinition.name}.${columnName}`);
+      }
+      if (existing.backfill === void 0 && columnDefinition.backfillValue !== void 0) {
+        throw new TypeError(`Backfills cannot be added after a column exists: ${tableDefinition.name}.${columnName}`);
+      }
+      if (existing.backfill !== void 0 && columnDefinition.backfillValue === void 0) {
+        throw new TypeError(`Backfills cannot be removed: ${tableDefinition.name}.${columnName}`);
+      }
+      if (existing.backfill !== void 0 && columnDefinition.backfillValue !== void 0 && typeof columnDefinition.backfillValue !== "function" && !backfillsEqual(existing.backfill, columnDefinition.backfillValue)) {
+        throw new TypeError(`Backfills cannot change: ${tableDefinition.name}.${columnName}`);
+      }
+      const existingEnum = existing.enumValues;
+      const definedEnum = columnDefinition.enumValues;
+      if (definedEnum !== void 0 && existingEnum === void 0) {
+        throw new TypeError(`Plain string columns cannot tighten to an enum: ${tableDefinition.name}.${columnName}. Existing rows may hold values outside the set.`);
+      }
+      if (existingEnum !== void 0) {
+        if (definedEnum === void 0) {
+          steps.push({
+            kind: "widen-enum",
+            tableName: tableDefinition.name,
+            columnName,
+            enumValues: null
+          });
+        } else {
+          const removed = existingEnum.filter((value) => !definedEnum.includes(value));
+          if (removed.length > 0) {
+            throw new TypeError(`Enum values cannot be removed: ${tableDefinition.name}.${columnName} drops ${removed.join(", ")}`);
+          }
+          if (definedEnum.some((value) => !existingEnum.includes(value))) {
             steps.push({
-                kind: "drop-column",
-                tableName: tableDefinition.name,
-                columnName: columnRecord.name,
+              kind: "widen-enum",
+              tableName: tableDefinition.name,
+              columnName,
+              enumValues: [...definedEnum]
             });
-        }
-        const existingKeyIds = record.primaryKeyColumnIds ??
-            (record.uniqueKeyColumnId === undefined ? [] : [record.uniqueKeyColumnId]);
-        const desiredKeyNames = tableDefinition.primaryKey.length > 0
-            ? tableDefinition.primaryKey
-            : Object.entries(tableDefinition.columns).flatMap(([name, definition]) => definition.isUnique ? [name] : []);
-        const desiredKeyIds = desiredKeyNames.map((name) => {
-            const definition = tableDefinition.columns[name];
-            const currentName = definition?.renamedFromName ?? name;
-            return recordColumnsByName.get(name)?.id ?? recordColumnsByName.get(currentName)?.id;
+          }
+        }
+      }
+      const existingIsKey = record.uniqueKeyColumnId === existing.id || (record.primaryKeyColumnIds ?? []).includes(existing.id);
+      const definedIsKey = columnDefinition.isUnique || tableDefinition.primaryKey.includes(columnName);
+      if (existingIsKey !== definedIsKey) {
+        throw new TypeError(`Unique keys cannot change: ${tableDefinition.name}.${columnName}`);
+      }
+      if (existing.nullable && !columnDefinition.isNullable) {
+        steps.push({
+          kind: "tighten-nullable",
+          tableName: tableDefinition.name,
+          columnName
         });
-        if (desiredKeyIds.length !== existingKeyIds.length ||
-            desiredKeyIds.some((id, index) => id !== existingKeyIds[index])) {
-            throw new TypeError(`Primary key order cannot change: ${tableDefinition.name}`);
-        }
-        planConstraintChanges(record, tableDefinition, steps);
-    }
-    if (options.schemaOwnsDatabase === true) {
-        const declaredTables = new Set(definition.tables.map(({ name }) => name));
-        for (const record of catalog.tables) {
-            // Only tables a migration created; see `managed`. Rows are at stake, so an undeclared
-            // table someone else made is never a migration's to remove.
-            if (declaredTables.has(record.name) || !record.managed)
-                continue;
-            steps.push({ kind: "drop-table", tableName: record.name });
-        }
+      }
+      if (!existing.nullable && columnDefinition.isNullable) {
+        steps.push({
+          kind: "widen-nullable",
+          tableName: tableDefinition.name,
+          columnName
+        });
+      }
+      if (!columnDefaultsEqual(existing.defaultValue, columnDefinition.defaultSpec)) {
+        const wasAuto = existing.defaultValue?.kind === "autoincrement";
+        const isAuto = columnDefinition.defaultSpec?.kind === "autoincrement";
+        if (wasAuto !== isAuto) {
+          steps.push({
+            kind: "set-auto-increment",
+            tableName: tableDefinition.name,
+            columnName,
+            enabled: isAuto
+          });
+        } else {
+          steps.push({
+            kind: "alter-default",
+            tableName: tableDefinition.name,
+            columnName,
+            defaultValue: columnDefinition.defaultSpec ?? null
+          });
+        }
+      }
+      const existingGenerated = existing.generatedValue;
+      const definedGenerated = columnDefinition.generatedSpec;
+      if (JSON.stringify(existingGenerated ?? null) !== JSON.stringify(definedGenerated ?? null)) {
+        steps.push({
+          kind: "alter-generated",
+          tableName: tableDefinition.name,
+          columnName,
+          generatedValue: definedGenerated ?? null
+        });
+      }
+    }
+    for (const columnRecord of record.columns) {
+      if (definedNames.has(columnRecord.name) || renameSources.has(columnRecord.name))
+        continue;
+      assertColumnDroppable(record, columnRecord);
+      steps.push({
+        kind: "drop-column",
+        tableName: tableDefinition.name,
+        columnName: columnRecord.name
+      });
+    }
+    const existingKeyIds = record.primaryKeyColumnIds ?? (record.uniqueKeyColumnId === void 0 ? [] : [record.uniqueKeyColumnId]);
+    const desiredKeyNames = tableDefinition.primaryKey.length > 0 ? tableDefinition.primaryKey : Object.entries(tableDefinition.columns).flatMap(([name, definition2]) => definition2.isUnique ? [name] : []);
+    const desiredKeyIds = desiredKeyNames.map((name) => {
+      const definition2 = tableDefinition.columns[name];
+      const currentName = definition2?.renamedFromName ?? name;
+      return recordColumnsByName.get(name)?.id ?? recordColumnsByName.get(currentName)?.id;
+    });
+    if (desiredKeyIds.length !== existingKeyIds.length || desiredKeyIds.some((id, index) => id !== existingKeyIds[index])) {
+      throw new TypeError(`Primary key order cannot change: ${tableDefinition.name}`);
+    }
+    planConstraintChanges(record, tableDefinition, steps);
+  }
+  if (options.schemaOwnsDatabase === true) {
+    const declaredTables = new Set(definition.tables.map(({ name }) => name));
+    for (const record of catalog.tables) {
+      if (declaredTables.has(record.name) || !record.managed)
+        continue;
+      steps.push({ kind: "drop-table", tableName: record.name });
     }
-    planViewSteps(catalog, definition, steps);
-    // A managed view can depend on a managed table the same authoritative schema removes. Drop
-    // dependents first; the SQL engine correctly refuses the reverse order. Replacements stay
-    // after table-creation steps so a newly declared body can resolve its sources.
-    const droppedViews = steps.filter((step) => step.kind === "drop-view");
-    const droppedTables = steps.filter((step) => step.kind === "drop-table");
-    return {
-        steps: [
-            ...steps.filter((step) => step.kind !== "drop-view" && step.kind !== "drop-table"),
-            ...droppedViews,
-            ...droppedTables,
-        ],
-    };
+  }
+  planViewSteps(catalog, definition, steps);
+  const droppedViews = steps.filter((step) => step.kind === "drop-view");
+  const droppedTables = steps.filter((step) => step.kind === "drop-table");
+  return {
+    steps: [
+      ...steps.filter((step) => step.kind !== "drop-view" && step.kind !== "drop-table"),
+      ...droppedViews,
+      ...droppedTables
+    ]
+  };
 }
-/**
- * A thin, fully typed SQL handle: inserts require every non-nullable column, updates exclude the
- * unique key, and reads return the complete inferred row shape. Every operation is rendered as
- * parameterized SQL and goes through the parser/planner/executor; this helper has no private
- * batch or table-read semantics that can drift from SQL.
- */
-export function typedTable(database, definition) {
-    const columnNames = Object.keys(definition.columns);
-    const quote = (name) => `"${name.replaceAll('"', '""')}"`;
-    const scalarUniqueKey = Object.entries(definition.columns).find(([, columnDefinition]) => columnDefinition.isUnique)?.[0];
-    const keyColumns = definition.primaryKey.length > 0
-        ? [...definition.primaryKey]
-        : scalarUniqueKey === undefined
-            ? []
-            : [scalarUniqueKey];
-    const normalizedRows = (rows) => {
-        if (rows.length === 0)
-            throw new TypeError("A batch needs at least one row");
-        // Keep extra runtime keys in the SQL column list. TypeScript normally excludes them, but a
-        // cast or JavaScript caller must still get the engine's "column does not exist" error rather
-        // than having data silently discarded by this facade.
-        const names = new Set(columnNames);
-        for (const row of rows)
-            for (const name of Object.keys(row))
-                names.add(name);
-        const ordered = [...names];
-        return { names: ordered, rows };
-    };
-    const insert = (rows, replace) => {
-        const normalized = normalizedRows(rows);
-        const params = [];
-        const values = normalized.rows
-            .map((row) => {
-            const placeholders = normalized.names.map((name) => {
-                const value = row[name];
-                if (!Object.hasOwn(row, name) || value === undefined)
-                    return "DEFAULT";
-                params.push(value);
-                return `$${String(params.length)}`;
-            });
-            return `(${placeholders.join(", ")})`;
-        })
-            .join(", ");
-        let sql = `INSERT INTO ${quote(definition.name)} (${normalized.names.map(quote).join(", ")}) VALUES ${values}`;
-        if (replace) {
-            if (keyColumns.length === 0) {
-                throw new TypeError(`Upsert requires a unique key: ${definition.name}`);
-            }
-            sql += ` ON CONFLICT (${keyColumns.map(quote).join(", ")}) DO REPLACE`;
-        }
-        return database.execute(sql, params);
-    };
-    const requireUniqueKey = (operation) => {
-        if (keyColumns.length === 0) {
-            throw new TypeError(`${operation} requires a table with a unique key: ${definition.name}`);
-        }
-        return keyColumns;
-    };
-    const keyParts = (key) => {
-        if (keyColumns.length === 1)
-            return [key];
-        if (typeof key !== "object" || key === null) {
-            throw new TypeError(`Composite key for ${definition.name} must be an object`);
-        }
-        return keyColumns.map((name) => key[name]);
-    };
-    const keyToken = (value) => {
-        const parts = keyParts(value);
-        return JSON.stringify(parts.map((part) => part instanceof Date ? ["date", dateMilliseconds(part)] : [typeof part, String(part)]));
-    };
-    const assertKeys = (keys, operation) => {
-        if (keys.length === 0)
-            throw new TypeError(`A ${operation} batch needs at least one key`);
-        const seen = new Set();
-        for (const key of keys) {
-            if (keyParts(key).some((part) => part === undefined || part === null)) {
-                throw new TypeError(`Missing ${operation} key value for ${definition.name}`);
-            }
-            const token = keyToken(key);
-            if (seen.has(token))
-                throw new TypeError(`Duplicate key in ${operation} batch: ${String(key)}`);
-            seen.add(token);
-        }
-    };
-    return {
-        definition,
-        insert: (rows) => insert(rows, false),
-        upsert: (rows) => insert(rows, true),
-        update: (input) => {
-            const keys = requireUniqueKey("UPDATE");
-            assertKeys(input.keys, "update");
-            const assignments = [];
-            const params = [];
-            for (const [name, rawValues] of Object.entries(input.changes)) {
-                if (!(name in definition.columns)) {
-                    // Render it anyway so SQL owns the public validation error.
-                }
-                const values = rawValues;
-                if (values.length !== input.keys.length) {
-                    throw new TypeError(`Update column ${name} has ${String(values.length)} values for ${String(input.keys.length)} keys`);
-                }
-                const branches = [];
-                values.forEach((value, index) => {
-                    if (value === undefined)
-                        return;
-                    const keyValue = input.keys[index];
-                    if (keyValue === undefined) {
-                        throw new TypeError(`Missing update key at position ${String(index)}`);
-                    }
-                    const conditions = keyParts(keyValue).map((part, keyIndex) => {
-                        params.push(part);
-                        return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
-                    });
-                    params.push(value);
-                    branches.push(`WHEN ${conditions.join(" AND ")} THEN $${String(params.length)}`);
-                });
-                if (branches.length > 0) {
-                    assignments.push(`${quote(name)} = CASE ${branches.join(" ")} ELSE ${quote(name)} END`);
-                }
-            }
-            if (assignments.length === 0)
-                throw new TypeError("An update batch needs at least one change");
-            const predicates = input.keys.map((keyValue) => {
-                const conditions = keyParts(keyValue).map((part, keyIndex) => {
-                    params.push(part);
-                    return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
-                });
-                return `(${conditions.join(" AND ")})`;
-            });
-            return database.execute(`UPDATE ${quote(definition.name)} SET ${assignments.join(", ")} WHERE ${predicates.join(" OR ")}`, params);
-        },
-        delete: (input) => {
-            const keys = requireUniqueKey("DELETE");
-            assertKeys(input.keys, "delete");
-            const params = [];
-            const predicates = input.keys.map((keyValue) => {
-                const conditions = keyParts(keyValue).map((part, keyIndex) => {
-                    params.push(part);
-                    return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
-                });
-                return `(${conditions.join(" AND ")})`;
-            });
-            return database.execute(`DELETE FROM ${quote(definition.name)} WHERE ${predicates.join(" OR ")}`, params);
-        },
-        rows: async () => (await database.query(`SELECT ${columnNames.map(quote).join(", ")} FROM ${quote(definition.name)}`)).rows,
-    };
+function typedTable(database, definition) {
+  const columnNames = Object.keys(definition.columns);
+  const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+  const scalarUniqueKey = Object.entries(definition.columns).find(([, columnDefinition]) => columnDefinition.isUnique)?.[0];
+  const keyColumns = definition.primaryKey.length > 0 ? [...definition.primaryKey] : scalarUniqueKey === void 0 ? [] : [scalarUniqueKey];
+  const normalizedRows = (rows) => {
+    if (rows.length === 0)
+      throw new TypeError("A batch needs at least one row");
+    const names = new Set(columnNames);
+    for (const row of rows)
+      for (const name of Object.keys(row))
+        names.add(name);
+    const ordered = [...names];
+    return { names: ordered, rows };
+  };
+  const insert = (rows, replace) => {
+    const normalized = normalizedRows(rows);
+    const params = [];
+    const values = normalized.rows.map((row) => {
+      const placeholders = normalized.names.map((name) => {
+        const value = row[name];
+        if (!Object.hasOwn(row, name) || value === void 0)
+          return "DEFAULT";
+        params.push(value);
+        return `$${String(params.length)}`;
+      });
+      return `(${placeholders.join(", ")})`;
+    }).join(", ");
+    let sql = `INSERT INTO ${quote(definition.name)} (${normalized.names.map(quote).join(", ")}) VALUES ${values}`;
+    if (replace) {
+      if (keyColumns.length === 0) {
+        throw new TypeError(`Upsert requires a unique key: ${definition.name}`);
+      }
+      sql += ` ON CONFLICT (${keyColumns.map(quote).join(", ")}) DO REPLACE`;
+    }
+    return database.execute(sql, params);
+  };
+  const requireUniqueKey = (operation) => {
+    if (keyColumns.length === 0) {
+      throw new TypeError(`${operation} requires a table with a unique key: ${definition.name}`);
+    }
+    return keyColumns;
+  };
+  const keyParts = (key) => {
+    if (keyColumns.length === 1)
+      return [key];
+    if (typeof key !== "object" || key === null) {
+      throw new TypeError(`Composite key for ${definition.name} must be an object`);
+    }
+    return keyColumns.map((name) => key[name]);
+  };
+  const keyToken = (value) => {
+    const parts = keyParts(value);
+    return JSON.stringify(parts.map((part) => part instanceof Date ? ["date", dateMilliseconds(part)] : [typeof part, String(part)]));
+  };
+  const assertKeys = (keys, operation) => {
+    if (keys.length === 0)
+      throw new TypeError(`A ${operation} batch needs at least one key`);
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of keys) {
+      if (keyParts(key).some((part) => part === void 0 || part === null)) {
+        throw new TypeError(`Missing ${operation} key value for ${definition.name}`);
+      }
+      const token = keyToken(key);
+      if (seen.has(token))
+        throw new TypeError(`Duplicate key in ${operation} batch: ${String(key)}`);
+      seen.add(token);
+    }
+  };
+  return {
+    definition,
+    insert: (rows) => insert(rows, false),
+    upsert: (rows) => insert(rows, true),
+    update: (input) => {
+      const keys = requireUniqueKey("UPDATE");
+      assertKeys(input.keys, "update");
+      const assignments = [];
+      const params = [];
+      for (const [name, rawValues] of Object.entries(input.changes)) {
+        if (!(name in definition.columns)) {
+        }
+        const values = rawValues;
+        if (values.length !== input.keys.length) {
+          throw new TypeError(`Update column ${name} has ${String(values.length)} values for ${String(input.keys.length)} keys`);
+        }
+        const branches = [];
+        values.forEach((value, index) => {
+          if (value === void 0)
+            return;
+          const keyValue = input.keys[index];
+          if (keyValue === void 0) {
+            throw new TypeError(`Missing update key at position ${String(index)}`);
+          }
+          const conditions = keyParts(keyValue).map((part, keyIndex) => {
+            params.push(part);
+            return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
+          });
+          params.push(value);
+          branches.push(`WHEN ${conditions.join(" AND ")} THEN $${String(params.length)}`);
+        });
+        if (branches.length > 0) {
+          assignments.push(`${quote(name)} = CASE ${branches.join(" ")} ELSE ${quote(name)} END`);
+        }
+      }
+      if (assignments.length === 0)
+        throw new TypeError("An update batch needs at least one change");
+      const predicates = input.keys.map((keyValue) => {
+        const conditions = keyParts(keyValue).map((part, keyIndex) => {
+          params.push(part);
+          return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
+        });
+        return `(${conditions.join(" AND ")})`;
+      });
+      return database.execute(`UPDATE ${quote(definition.name)} SET ${assignments.join(", ")} WHERE ${predicates.join(" OR ")}`, params);
+    },
+    delete: (input) => {
+      const keys = requireUniqueKey("DELETE");
+      assertKeys(input.keys, "delete");
+      const params = [];
+      const predicates = input.keys.map((keyValue) => {
+        const conditions = keyParts(keyValue).map((part, keyIndex) => {
+          params.push(part);
+          return `${quote(keys[keyIndex] ?? "")} = $${String(params.length)}`;
+        });
+        return `(${conditions.join(" AND ")})`;
+      });
+      return database.execute(`DELETE FROM ${quote(definition.name)} WHERE ${predicates.join(" OR ")}`, params);
+    },
+    rows: async () => (await database.query(`SELECT ${columnNames.map(quote).join(", ")} FROM ${quote(definition.name)}`)).rows
+  };
 }
-/** Applies one table's alteration steps onto its current column records. */
-export function applyColumnSteps(record, steps, createId) {
-    const columns = structuredClone(record.columns);
-    for (const step of steps) {
-        if (step.kind === "rename-column") {
-            const target = columns.find(({ name }) => name === step.from);
-            if (target !== undefined)
-                target.name = step.to;
-            continue;
-        }
-        if (step.kind === "add-column") {
-            if (!columns.some(({ name }) => name === step.columnName)) {
-                columns.push({
-                    id: createId(),
-                    name: step.columnName,
-                    type: step.definition.type,
-                    ...(step.definition.integer ? { integer: true } : {}),
-                    ...(step.definition.sqlDomain === undefined
-                        ? {}
-                        : { sqlDomain: structuredClone(step.definition.sqlDomain) }),
-                    // A backfill is what lets the column be non-nullable: every row has a value, either
-                    // written or substituted at read time.
-                    nullable: step.backfill === undefined ? true : step.definition.isNullable,
-                    ...(step.backfill === undefined
-                        ? {}
-                        : {
-                            backfill: storedBackfill(step.definition, step.backfill),
-                        }),
-                    ...(step.definition.defaultSpec === undefined
-                        ? {}
-                        : { defaultValue: step.definition.defaultSpec }),
-                    ...(step.definition.enumValues === undefined
-                        ? {}
-                        : { enumValues: [...step.definition.enumValues] }),
-                });
-            }
-            continue;
-        }
-        if (step.kind === "widen-enum") {
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined) {
-                if (step.enumValues === null)
-                    delete target.enumValues;
-                else
-                    target.enumValues = [...step.enumValues];
-            }
-            continue;
-        }
-        if (step.kind === "widen-nullable") {
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined)
-                target.nullable = true;
-            continue;
-        }
-        if (step.kind === "drop-column") {
-            // The column record goes; the stored blocks stay until compaction rewrites the segments
-            // that hold them, which is what keeps the drop a metadata step.
-            const index = columns.findIndex(({ name }) => name === step.columnName);
-            if (index !== -1)
-                columns.splice(index, 1);
-            continue;
-        }
-        if (step.kind === "tighten-nullable") {
-            // The proof happens before this runs; see MinnowDatabase#columnHoldsNull.
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined)
-                target.nullable = false;
-            continue;
-        }
-        if (step.kind === "set-auto-increment") {
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined) {
-                if (step.enabled)
-                    target.defaultValue = { kind: "autoincrement" };
-                else
-                    delete target.defaultValue;
-            }
-            continue;
-        }
-        if (step.kind === "alter-default") {
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined) {
-                if (step.defaultValue === null)
-                    delete target.defaultValue;
-                else
-                    target.defaultValue = step.defaultValue;
-            }
-            continue;
-        }
-        if (step.kind === "alter-generated") {
-            const target = columns.find(({ name }) => name === step.columnName);
-            if (target !== undefined) {
-                if (step.generatedValue === null)
-                    delete target.generatedValue;
-                else
-                    target.generatedValue = step.generatedValue;
-            }
-        }
+function applyColumnSteps(record, steps, createId) {
+  const columns = structuredClone(record.columns);
+  for (const step of steps) {
+    if (step.kind === "rename-column") {
+      const target = columns.find(({ name }) => name === step.from);
+      if (target !== void 0)
+        target.name = step.to;
+      continue;
+    }
+    if (step.kind === "add-column") {
+      if (!columns.some(({ name }) => name === step.columnName)) {
+        columns.push({
+          id: createId(),
+          name: step.columnName,
+          type: step.definition.type,
+          ...step.definition.integer ? { integer: true } : {},
+          ...step.definition.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(step.definition.sqlDomain) },
+          nullable: step.backfill === void 0 ? true : step.definition.isNullable,
+          ...step.backfill === void 0 ? {} : {
+            backfill: storedBackfill(step.definition, step.backfill)
+          },
+          ...step.definition.defaultSpec === void 0 ? {} : { defaultValue: step.definition.defaultSpec },
+          ...step.definition.enumValues === void 0 ? {} : { enumValues: [...step.definition.enumValues] }
+        });
+      }
+      continue;
+    }
+    if (step.kind === "widen-enum") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0) {
+        if (step.enumValues === null)
+          delete target.enumValues;
+        else
+          target.enumValues = [...step.enumValues];
+      }
+      continue;
     }
-    return columns;
+    if (step.kind === "widen-nullable") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0)
+        target.nullable = true;
+      continue;
+    }
+    if (step.kind === "drop-column") {
+      const index = columns.findIndex(({ name }) => name === step.columnName);
+      if (index !== -1)
+        columns.splice(index, 1);
+      continue;
+    }
+    if (step.kind === "tighten-nullable") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0)
+        target.nullable = false;
+      continue;
+    }
+    if (step.kind === "set-auto-increment") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0) {
+        if (step.enabled)
+          target.defaultValue = { kind: "autoincrement" };
+        else
+          delete target.defaultValue;
+      }
+      continue;
+    }
+    if (step.kind === "alter-default") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0) {
+        if (step.defaultValue === null)
+          delete target.defaultValue;
+        else
+          target.defaultValue = step.defaultValue;
+      }
+      continue;
+    }
+    if (step.kind === "alter-generated") {
+      const target = columns.find(({ name }) => name === step.columnName);
+      if (target !== void 0) {
+        if (step.generatedValue === null)
+          delete target.generatedValue;
+        else
+          target.generatedValue = step.generatedValue;
+      }
+    }
+  }
+  return columns;
 }
 function columnDefaultsEqual(left, right) {
-    if (left === undefined || right === undefined)
-        return left === right;
-    if (left.kind !== right.kind)
-        return false;
-    if (left.kind === "expression" && right.kind === "expression")
-        return left.sql === right.sql;
-    if (left.kind !== "literal" || right.kind !== "literal")
-        return true;
-    if (left.value instanceof Date || right.value instanceof Date) {
-        return (left.value instanceof Date &&
-            right.value instanceof Date &&
-            dateMilliseconds(left.value) === dateMilliseconds(right.value));
-    }
-    return left.value === right.value;
+  if (left === void 0 || right === void 0)
+    return left === right;
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind === "expression" && right.kind === "expression")
+    return left.sql === right.sql;
+  if (left.kind !== "literal" || right.kind !== "literal")
+    return true;
+  if (left.value instanceof Date || right.value instanceof Date) {
+    return left.value instanceof Date && right.value instanceof Date && dateMilliseconds(left.value) === dateMilliseconds(right.value);
+  }
+  return left.value === right.value;
 }
+export {
+  applyColumnSteps,
+  assertColumnDroppable,
+  column,
+  columnFromState,
+  compileGeneratedColumnExpression,
+  declaredForeignKeys,
+  foreignKeyName,
+  isDestructiveStep,
+  planMigration,
+  schema,
+  table,
+  typedTable,
+  view
+};