@prisma/orm-target-sqlite 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/sqlite-migration-BAdSmooi-iWFVQgGV.mjs

@@ -0,0 +1,1295 @@
+import { a as SQLITE_INTEGER_CODEC_ID, c as SQLITE_TEXT_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-wgEvkCkg-WltuexMR.mjs";
+import { a as sqliteCharacterVarying, d as sqliteReal, f as sqliteText, l as sqliteInteger, r as sqliteCharacter, s as sqliteDatetime, t as sqliteBlob, u as sqliteJson } from "./data-types-coQrCWfS-yMCe4F52.mjs";
+import { n as sqliteError, t as errorSqliteMigrationStackMissing } from "./errors-DnR-sMHS-D_gh214a.mjs";
+import { n as encodeSqliteDatetime } from "./codecs-yZoH21Yj-lQXtGlEq.mjs";
+import { n as escapeLiteral } from "./sql-utils-XGT5Esi2-Zr2mqJf8.mjs";
+import { n as SqliteContractView } from "./sqlite-contract-view-CGfiGvKH-CT-JjNHd.mjs";
+import { n as sqliteResolveDefault } from "./default-normalizer-DGMXypHg-CPf7oyZA.mjs";
+import { S as sqliteIdentifiersCollide, _ as indexReplacementCalls, a as DropColumnCall, b as renameTableSteps, c as INLINE_AUTOINCREMENT_PRIMARY_KEY, d as RenameColumnCall, f as RenameTableCall, h as buildRecreateSummary, i as DataTransformCall, m as buildRecreatePostchecks, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as RecreateTableCall, x as sqliteDefaultToDdlColumnDefault } from "./op-factory-call-emj9Xp05-BFLkxrAK.mjs";
+import { t as CONTROL_TABLE_NAMES } from "./control-tables-D_o8dKRB-n_QqsXcm.mjs";
+import { DdlColumn, ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from "@prisma/orm-family-sql/relational-core/ast";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { dataTypeParams } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { isSqlDataType, nameIsCatalogText, renderSqlTypeName, sqlDataTypeOfCodec } from "@prisma/orm-family-sql/contract/data-type";
+import { diffSchemas, issueOutcome, orderIssuesByDependencies } from "@prisma/orm-framework/components/control";
+import { sqlTextOf } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma/orm-framework/components/ir";
+import { contractToSchemaIR, extractCodecControlHooks, resolveColumnRenameAgainst, resolveTableRenameAgainst, sqlTypeLookupsOf, unmatchedColumnRename, unmatchedTableRename } from "@prisma/orm-family-sql/family/control";
+import { PrimaryKey, RelationalSchemaNodeKind, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlTableIR, SqlUniqueIR, relationalNodeGranularity, sqlColumnTypesEqual } from "@prisma/orm-family-sql/schema-ir/types";
+import { verifySqlSchemaByDiff } from "@prisma/orm-family-sql/family/diff";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { namingOf, namingOfLiveName, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
+import { isArrayEqual } from "@prisma/orm-framework/utils/array-equal";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { MigrationContractViews } from "@prisma/orm-toolchain/migration-tools/migration";
+//#region ../../../3-targets/sqlite/1-target/dist/sqlite-migration-BAdSmooi.mjs
+/**
+* The SQLite expected-side projection: contract → flat relational schema IR.
+*
+* Each column's type is written from the data type its codec represents.
+* Every expected column also carries its `codecRef` unconditionally
+* (Decision 5) — the planner's op-builders resolve DDL rendering from it at
+* plan time, so no separate render stamper is threaded here.
+*/
+function sqliteContractToSchema(contract, types) {
+	return contractToSchemaIR(contract, {
+		annotationNamespace: "sqlite",
+		resolveDefault: sqliteResolveDefault,
+		dataTypeLookup: types.dataTypeLookup,
+		codecLookup: types.codecLookup
+	});
+}
+/**
+* The SQLite schema verify: the full-tree node-diff verdict wrapped in the
+* issue-based result envelope. Used by the runner's post-apply check; the
+* family `verifySchema` runs the same composition via the descriptor hook.
+*/
+function verifySqliteDatabaseSchema(input) {
+	return verifySqlSchemaByDiff({
+		contract: input.contract,
+		schema: input.actualSchema,
+		strict: input.strict,
+		frameworkComponents: input.frameworkComponents,
+		diffSchema: diffSqliteSchema,
+		granularityOf: relationalNodeGranularity
+	});
+}
+/**
+* Resolves a verdict-diff issue's subject table's declared control policy
+* directly from the contract. SQLite's expected tree is flat, so the issue
+* path carries no namespace segment — `path[1]` is the table name (`path[0]`
+* is the tree root's own id); every contract namespace is searched for that
+* table name (table names are globally unique in the flat tree — duplicates
+* across namespaces are rejected earlier, at `contractToSchemaIR`).
+*/
+function resolveControlPolicy(issue, contract) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return void 0;
+	for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+		const table = entityAt(contract.storage, {
+			namespaceId,
+			entityKind: "table",
+			entityName: tableName
+		});
+		if (table !== void 0) return table.control;
+	}
+}
+/**
+* The SQLite full-tree node diff for the family verify verdict: derive the
+* expected flat tree with resolved leaf values (parameterized types written
+* with their parameters; FK nodes born with the flat empty
+* `resolvedReferencedNamespace`), and run the generic differ over the trees
+* as derived. Flat targets need no ownership scoping. The codec `verifyType`
+* hooks run once per contract namespace with tables, each against the sole
+* flat actual root — exactly the legacy per-namespace pairing.
+*/
+function diffSqliteSchema(input) {
+	const types = sqlTypeLookupsOf(input.frameworkComponents);
+	const expected = sqliteContractToSchema(input.contract, types);
+	const actual = input.schema instanceof SqlSchemaIR ? input.schema : blindCast(input.schema);
+	return {
+		issues: diffSchemas(expected, actual),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, input.contract),
+		namespacePairs: Object.values(input.contract.storage.namespaces).filter((ns) => Object.keys(ns.entries.table ?? {}).length > 0).map(() => ({ actual }))
+	};
+}
+/**
+* The SQLite planner's diff input: the same tree-building
+* `diffSqliteSchema` uses (FK nodes born flat). One differ
+* drives both verify and plan over the trees as derived; this is the plan-side
+* derivation — column DDL resolves from each expected column's `codecRef` at
+* plan time (`column-ddl-rendering.ts`), so no separate render stamping happens here.
+*/
+function buildSqlitePlanDiff(input) {
+	const types = sqlTypeLookupsOf(input.frameworkComponents);
+	const expected = sqliteContractToSchema(input.contract, types);
+	const actual = sqliteActualSchema(input.actualSchema);
+	return {
+		expected,
+		actual,
+		issues: diffSchemas(expected, actual)
+	};
+}
+/** The schema a plan starts from as a `SqlSchemaIR`, its table and column names taken from their keys. */
+function sqliteActualSchema(actualSchema) {
+	return new SqlSchemaIR(withRecordKeyNames(actualSchema));
+}
+/**
+* Every schema-tree builder in this codebase derives a table's / column's
+* `name` from the record key it's stored under (`contractToSchemaIR`,
+* the SQLite introspection adapter) rather than trusting a redundant
+* embedded field — the record key IS the identity. Mirrors that discipline
+* for the actual/live tree before construction, so `SqlTableIR.id` /
+* `SqlColumnIR.id` (both derived from `.name`) are always correct without
+* requiring every caller to duplicate the key onto the value. A no-op for a
+* tree that already carries matching names (the real introspection adapter
+* always does).
+*/
+function withRecordKeyNames(actualSchema) {
+	const raw = blindCast(actualSchema);
+	const tables = {};
+	for (const [tableName, table] of Object.entries(raw.tables ?? {})) {
+		const rawTable = blindCast(table);
+		const columns = {};
+		for (const [columnName, column] of Object.entries(blindCast(table).columns ?? {})) columns[columnName] = column instanceof SqlColumnIR ? column.name === columnName ? column : column.withName(columnName) : {
+			...blindCast(column),
+			name: columnName
+		};
+		tables[tableName] = {
+			...rawTable,
+			name: tableName,
+			columns,
+			foreignKeys: rawTable.foreignKeys ?? [],
+			uniques: rawTable.uniques ?? [],
+			indexes: rawTable.indexes ?? []
+		};
+	}
+	return { tables };
+}
+/**
+* The type DDL writes for a column node: the name of the type it is stored as, with the parameters as the contract writes them, in upper case, or as given for a data type whose name is its catalog text, since verify compares that text exactly (ADR 273).
+*/
+function columnTypeSql(column) {
+	const type = column.storedType;
+	if (type === void 0 || !isSqlDataType(type)) throw new InternalError(`column "${column.name}" has no data type; the expected tree must be derived via contractToSchemaIR for planning`);
+	const written = renderSqlTypeName(type, dataTypeParams(type, column.codecRef?.typeParams));
+	return nameIsCatalogText(type) ? written : written.toUpperCase();
+}
+/** The default DDL writes: the one the contract authored; `resolvedDefault` exists for the diff comparison. */
+function ddlDefaultOf(column) {
+	return column.authoredDefault ?? column.resolvedDefault;
+}
+/**
+* True when the column is rendered inline as `INTEGER PRIMARY KEY
+* AUTOINCREMENT` — the sole member of the table's primary key with an
+* `autoincrement()` default. Node-based sibling of the retired
+* `isInlineAutoincrementPrimaryKey` (which read the raw `StorageTable`);
+* reads the table/column nodes instead.
+*/
+function isInlineAutoincrementPrimaryKeyNode(table, column) {
+	if (table.primaryKey?.columns.length !== 1) return false;
+	if (table.primaryKey.columns[0] !== column.name) return false;
+	return column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()";
+}
+/**
+* Builds the flat `SqliteColumnSpec` `AddColumnCall` / `RecreateTableCall`
+* need, with the type the column is stored as.
+*/
+function columnSpecFromNode(column, inline) {
+	const typeSql = columnTypeSql(column);
+	return {
+		name: column.name,
+		typeSql,
+		...inline ? {} : {
+			...ifDefined("default", ddlDefaultOf(column)),
+			...ifDefined("codecRef", column.codecRef)
+		},
+		nullable: column.nullable,
+		...inline ? { inlineAutoincrementPrimaryKey: true } : {}
+	};
+}
+/**
+* Builds the `DdlColumn` the `CreateTableCall` path needs, with the type the
+* column is stored as.
+*/
+function ddlColumnFromNode(column, inline) {
+	const typeSql = columnTypeSql(column);
+	if (inline) return new DdlColumn({
+		name: column.name,
+		type: `${typeSql}${INLINE_AUTOINCREMENT_PRIMARY_KEY}`
+	});
+	const colDefault = sqliteDefaultToDdlColumnDefault(ddlDefaultOf(column));
+	return new DdlColumn({
+		name: column.name,
+		type: typeSql,
+		...!column.nullable ? { notNull: true } : {},
+		...colDefault !== void 0 ? { default: colDefault } : {},
+		...column.codecRef !== void 0 ? { codecRef: column.codecRef } : {}
+	});
+}
+/**
+* Builds the table-level constraints (PK / unique / FK) for a `CreateTable`
+* path from the table node — the node-sourced sibling of the retired
+* contract-based `tableToDdlParts`'s constraint half.
+*
+* A check constraint on the table node throws rather than being dropped.
+* `@@check` is refused earlier, by the `sql.checkConstraint` capability gate in
+* PSL interpretation. The TS `check()` builder is not gated there — capabilities
+* are adapter-reported and reach the contract only after it is built — so a
+* `check()` declared against SQLite arrives here, and this is where it is
+* refused. It is the primary enforcement point for that surface, and the safety
+* net for a contract that reached storage some other way.
+*/
+function tableConstraintsFromNode(table, hasInlinePk) {
+	const constraints = [];
+	if (table.primaryKey && !hasInlinePk) constraints.push(new PrimaryKeyConstraint({ columns: table.primaryKey.columns }));
+	for (const check of table.checks ?? []) throw sqliteError("CONTRACT.CONSTRAINT_INVALID", `The SQLite target does not support CHECK constraints (constraint "${check.name}" on table "${table.name}"). The "checkConstraint" capability is Postgres-only — remove the "@@check" / "check()" declaration, or target Postgres.`, { meta: {
+		constraintName: check.name,
+		tableName: table.name
+	} });
+	for (const u of table.uniques) constraints.push(new UniqueConstraint({
+		columns: u.columns,
+		...u.name !== void 0 ? { name: u.name } : {}
+	}));
+	for (const fk of table.foreignKeys) constraints.push(new ForeignKeyConstraint({
+		columns: fk.columns,
+		refTable: fk.referencedTable,
+		refColumns: fk.referencedColumns,
+		...fk.name !== void 0 ? { name: fk.name } : {},
+		...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+		...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+	}));
+	return constraints;
+}
+const DATA_TYPE_FILL_VALUES = /* @__PURE__ */ new Map([
+	[sqliteDatetime.id, `'${escapeLiteral(encodeSqliteDatetime(/* @__PURE__ */ new Date(0)))}'`],
+	[sqliteJson.id, `'{}'`],
+	[sqliteInteger.id, "0"],
+	[sqliteReal.id, "0"],
+	[sqliteText.id, "''"],
+	[sqliteCharacter.id, "''"],
+	[sqliteCharacterVarying.id, "''"],
+	[sqliteBlob.id, "X''"]
+]);
+function isParamRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* The SQL value a new required column takes in the rows a table already has, or `undefined` when
+* its type has none: the column's codec hook first, as on Postgres, then a value of its data type.
+*/
+function sqliteFillValue(column, codecHooks, types) {
+	const codecRef = column.codecRef;
+	if (codecRef === void 0 || column.many === true) return void 0;
+	const dataType = sqlDataTypeOfCodec(codecRef.codecId, types).id;
+	const fromHook = codecHooks.get(codecRef.codecId)?.resolveIdentityValue?.({
+		dataType,
+		codecId: codecRef.codecId,
+		...isParamRecord(codecRef.typeParams) ? { typeParams: codecRef.typeParams } : {}
+	});
+	if (fromHook !== void 0) return fromHook ?? void 0;
+	return DATA_TYPE_FILL_VALUES.get(dataType);
+}
+/**
+* SQLite migration strategies.
+*
+* Each strategy examines the node-typed issue list, consumes issues it
+* handles, and returns the `SqliteOpFactoryCall[]` to address them. The issue
+* planner runs each strategy in order and routes whatever's left through
+* `mapNodeIssueToCall`.
+*
+* SQLite has no enums and no component-declared database dependencies. The
+* recipe that needs strategy-level multi-issue consumption is `recreateTable`,
+* which absorbs type/nullability/default/constraint mismatches, and required
+* columns added to existing tables, for a given table into one rebuild.
+*/
+/**
+* Classifies a node issue into the operation class a recreate absorbing it
+* would need, or `null` when the strategy doesn't handle this node/reason at
+* all (table/column not-found-or-not-expected, and index issues — those are
+* standalone ops, never folded into a recreate).
+*
+* Column drift is a single `not-equal` issue (type and nullability compared
+* together by `SqlColumnIR.isEqualTo`): a type change is destructive, because
+* the copy can change values; a nullability change alone is widening, because
+* a tightening copy fails on a NULL rather than losing it.
+*/
+/** The column of a column issue, which `classifyNodeIssue` classes destructive only for a type change. */
+function columnNameOf(issue) {
+	return blindCast(issue.expected).name;
+}
+/**
+* The changes of codec a table rebuild's copy makes without losing a value: the column's type
+* affinity stores each old value as the same value of the new type. An integer becomes its decimal
+* text; a real is not listed, since SQLite writes it as text with fifteen significant digits. Keyed
+* by codec, not data type, because `Int` and `BigInt` differ only in their codec.
+*/
+const LOSSLESS_COPIES = /* @__PURE__ */ new Set([
+	`${SQLITE_INTEGER_CODEC_ID}→${SQLITE_TEXT_CODEC_ID}`,
+	`${SQLITE_BIGINT_CODEC_ID}→${SQLITE_TEXT_CODEC_ID}`,
+	`${SQLITE_INTEGER_CODEC_ID}→${SQLITE_BIGINT_CODEC_ID}`
+]);
+function copyKeepsEveryValue(fromCodec, to) {
+	const toCodec = to.codecRef?.codecId;
+	return fromCodec !== void 0 && toCodec !== void 0 && LOSSLESS_COPIES.has(`${fromCodec}→${toCodec}`);
+}
+function classifyNodeIssue(issue, ctx) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return null;
+	switch (blindCast(node).nodeKind) {
+		case RelationalSchemaNodeKind.column: {
+			if (issueOutcome(issue) !== "not-equal") return null;
+			const expected = blindCast(issue.expected);
+			const actual = blindCast(issue.actual);
+			const fromCodec = ctx.originCodecId(String(issue.path[1]), actual.name);
+			return !sqlColumnTypesEqual(expected, actual) && !copyKeepsEveryValue(fromCodec, expected) ? "destructive" : "widening";
+		}
+		case RelationalSchemaNodeKind.columnDefault:
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.foreignKey:
+		case RelationalSchemaNodeKind.unique: return "widening";
+		default: return null;
+	}
+}
+function columnNode(node) {
+	return blindCast(node);
+}
+function isColumnIssue(issue) {
+	const node = issue.expected ?? issue.actual;
+	return node !== void 0 && blindCast(node).nodeKind === RelationalSchemaNodeKind.column;
+}
+/** The column a `--convert` or `--backfill` statement of `kind` names, if one names it. */
+function statementColumn(ctx, kind, tableName, columnName) {
+	if (!ctx.policy.allowedOperationClasses.includes("data")) return void 0;
+	return ctx.statementColumns[kind].find((column) => column.table === tableName && column.column === columnName);
+}
+/** A column the plan adds to a table the database already has. */
+function addedColumn(issue, ctx) {
+	if (issueOutcome(issue) !== "not-found" || !isColumnIssue(issue)) return void 0;
+	const tableName = issue.path[1];
+	if (tableName === void 0 || ctx.actual.tables[tableName] === void 0) return void 0;
+	return columnNode(issue.expected);
+}
+/**
+* A required column with no default that the plan adds to a table the database already has, so
+* existing rows need a value for it.
+*/
+function addedRequiredColumn(issue, ctx) {
+	const column = addedColumn(issue, ctx);
+	return column === void 0 || column.nullable || column.resolvedDefault !== void 0 ? void 0 : column;
+}
+const CLASS_ORDER = [
+	"additive",
+	"widening",
+	"data",
+	"destructive"
+];
+function highestClass(classes) {
+	return classes.reduce((highest, next) => CLASS_ORDER.indexOf(next) > CLASS_ORDER.indexOf(highest) ? next : highest, "additive");
+}
+/**
+* Groups recreate-eligible issues by table and emits one `RecreateTableCall` per table, removing
+* the issues it consumed so `mapNodeIssueToCall` does not handle them again.
+*
+* - A type change is `destructive`, since the copy can change values, unless a `--convert`
+*   statement names the column: the copy then goes through a slot the user fills, and the rebuild
+*   is `data`. Either way the rebuild checks after its copy that every value took the new type.
+* - A nullability or constraint change alone is `widening`: a tightening copy fails on a NULL
+*   rather than losing it.
+* - A required column with no default added to an existing table is copied from a temporary value
+*   (`additive`). A column in a key or foreign key, whose values come from a value set, or whose
+*   type has no such value is carried with nothing to copy from: the rebuild succeeds on an empty
+*   table and fails on `NOT NULL` when the table has rows. A column a `--backfill` statement names
+*   was added nullable and filled by earlier calls, so the rebuild copies it like a live column.
+* - A rebuild that leaves a live column out loses its values, so it is `destructive`.
+* - Any other column added to a table the plan rebuilds, optional or with a default, and an index
+*   on it, are left to the rebuild, which creates them from the new table's spec. The plan has no
+*   separate add, so the rebuild's source table is the live one (`additive`).
+*
+* The table shapes come from `ctx.expected` and `ctx.actual`, keyed by table name: SQLite is a
+* flat, single-namespace target, and one issue only carries its own node.
+*/
+const recreateTableStrategy = (issues, ctx) => {
+	const byTable = /* @__PURE__ */ new Map();
+	const consumed = /* @__PURE__ */ new Set();
+	const codecHooks = extractCodecControlHooks(ctx.frameworkComponents);
+	const rebuildOf = (tableName) => {
+		const existing = byTable.get(tableName);
+		if (existing !== void 0) return existing;
+		const created = {
+			issues: [],
+			classes: [],
+			retypedColumns: [],
+			copyExpressions: {},
+			temporaryValues: {},
+			addedColumns: []
+		};
+		byTable.set(tableName, created);
+		return created;
+	};
+	for (const issue of issues) {
+		const tableName = issue.path[1];
+		if (tableName === void 0) continue;
+		const added = addedRequiredColumn(issue, ctx);
+		if (added !== void 0) {
+			const expectedTable = ctx.expected.tables[tableName];
+			if (statementColumn(ctx, "backfill", tableName, added.name) !== void 0) {
+				const rebuild = rebuildOf(tableName);
+				rebuild.issues.push(issue);
+				rebuild.addedColumns.push(added.name);
+				rebuild.classes.push("widening");
+				consumed.add(issue);
+				continue;
+			}
+			const fill = expectedTable === void 0 || !ctx.takesTemporaryValue(tableName, added.name) ? void 0 : sqliteFillValue(added, codecHooks, ctx.types);
+			const rebuild = rebuildOf(tableName);
+			rebuild.issues.push(issue);
+			if (fill !== void 0) rebuild.temporaryValues[added.name] = {
+				kind: "sql",
+				sql: fill
+			};
+			rebuild.classes.push("additive");
+			consumed.add(issue);
+			continue;
+		}
+		const cls = classifyNodeIssue(issue, ctx);
+		if (!cls) continue;
+		const rebuild = rebuildOf(tableName);
+		rebuild.issues.push(issue);
+		consumed.add(issue);
+		if (cls === "widening") {
+			rebuild.classes.push("widening");
+			continue;
+		}
+		const column = columnNameOf(issue);
+		const converted = statementColumn(ctx, "convert", tableName, column);
+		rebuild.retypedColumns.push(column);
+		if (converted === void 0) {
+			rebuild.classes.push("destructive");
+			continue;
+		}
+		rebuild.copyExpressions[column] = {
+			kind: "placeholder",
+			slot: `${converted.text}:convert`
+		};
+		rebuild.classes.push("data");
+	}
+	for (const issue of issues) {
+		const rebuild = byTable.get(issue.path[1] ?? "");
+		if (consumed.has(issue) || rebuild === void 0 || addedColumn(issue, ctx) === void 0) continue;
+		rebuild.issues.push(issue);
+		rebuild.classes.push("additive");
+		consumed.add(issue);
+	}
+	if (byTable.size === 0) return { kind: "no_match" };
+	const calls = [];
+	for (const [tableName, rebuild] of byTable) {
+		const expectedTable = ctx.expected.tables[tableName];
+		const actualTable = ctx.actual.tables[tableName];
+		if (!expectedTable || !actualTable) continue;
+		const leavesColumnsOut = Object.keys(actualTable.columns).some((column) => !Object.hasOwn(expectedTable.columns, column));
+		const operationClass = highestClass([...rebuild.classes, ...leavesColumnsOut ? ["destructive"] : []]);
+		const tableSpec = tableSpecFromNode(expectedTable);
+		const indexes = expectedTable.indexes.map((idx) => ({
+			name: idx.name,
+			columns: idx.columns ?? []
+		}));
+		calls.push(new RecreateTableCall({
+			tableName,
+			contractTable: tableSpec,
+			schemaColumnNames: [...Object.keys(actualTable.columns), ...rebuild.addedColumns],
+			indexes,
+			summary: buildRecreateSummary(tableName, rebuild.issues),
+			postchecks: [...buildRecreatePostchecks(tableName, rebuild.issues, tableSpec, /* @__PURE__ */ new Set([...Object.keys(rebuild.copyExpressions), ...Object.keys(rebuild.temporaryValues)]), new Set(tableSpec.columns.filter(({ name }) => statementColumn(ctx, "backfill", tableName, name) !== void 0).map(({ name }) => name)))],
+			operationClass,
+			copyExpressions: rebuild.copyExpressions,
+			temporaryValues: rebuild.temporaryValues,
+			retypedColumns: rebuild.retypedColumns
+		}));
+	}
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !consumed.has(i)),
+		calls,
+		recipe: true
+	};
+};
+/**
+* Writes the calls that come before the rebuild of a column a `--backfill` statement names: for a
+* required column added to an existing table, the nullable add and a data transform whose slot the
+* user fills; for a column made required, the data transform. The rebuild that makes the column
+* NOT NULL comes from `recreateTableStrategy`, so this strategy consumes no issue. Without the
+* statement, a tightening rebuild fails on a NULL rather than guessing a value for it.
+*/
+const nullabilityTighteningBackfillStrategy = (issues, ctx) => {
+	const calls = [];
+	for (const issue of issues) {
+		const tableName = issue.path[1];
+		if (tableName === void 0 || !isColumnIssue(issue)) continue;
+		const added = addedRequiredColumn(issue, ctx);
+		const tightened = issueOutcome(issue) === "not-equal" && !columnNode(issue.expected).nullable && columnNode(issue.actual).nullable ? columnNode(issue.expected) : void 0;
+		const column = added ?? tightened;
+		if (column === void 0) continue;
+		const named = statementColumn(ctx, "backfill", tableName, column.name);
+		if (named === void 0) continue;
+		if (added !== void 0) calls.push(new AddColumnCall(tableName, {
+			...columnSpecFromNode(added, false),
+			nullable: true
+		}));
+		calls.push(new DataTransformCall(`data_migration.backfill-${tableName}-${column.name}`, `Backfill NULLs in "${tableName}"."${column.name}" before NOT NULL tightening`, tableName, column.name, `${named.text}:run`));
+	}
+	if (calls.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues,
+		calls,
+		recipe: true
+	};
+};
+const sqlitePlannerStrategies = [nullabilityTighteningBackfillStrategy, recreateTableStrategy];
+/**
+* The generic differ is total: a missing/extra table (or column) emits an
+* issue for itself AND for every node in its subtree (columns, defaults,
+* constraints, indexes). `CreateTableCall`/`DropTableCall` and
+* `AddColumnCall`/`DropColumnCall` already account for the whole subtree
+* (reading it directly off the table/column node), so the nested issues are
+* redundant — coalescing them is "the planner's responsibility" the differ's
+* own contract assigns (`schema-diff.ts`). Drops any issue whose path is a
+* strict descendant of a `not-found`/`not-expected` issue's path.
+*/
+function coalesceSubtreeIssues(issues) {
+	const collapsingPaths = issues.filter((issue) => issueOutcome(issue) === "not-found" || issueOutcome(issue) === "not-expected").map((issue) => issue.path);
+	if (collapsingPaths.length === 0) return issues;
+	return issues.filter((issue) => !collapsingPaths.some((ancestor) => isStrictDescendantPath(issue.path, ancestor)));
+}
+function isStrictDescendantPath(path, ancestor) {
+	if (path.length <= ancestor.length) return false;
+	for (let i = 0; i < ancestor.length; i += 1) if (path[i] !== ancestor[i]) return false;
+	return true;
+}
+function issueNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node);
+}
+/**
+* Builds the flat `SqliteTableSpec` `RecreateTableCall` needs from the
+* expected table node — the node-sourced equivalent of the retired
+* `toTableSpec` (which read a raw contract `StorageTable`). Every column's
+* spec is resolved from its `codecRef` via `columnSpecFromNode`.
+*/
+function tableSpecFromNode(table) {
+	const columns = Object.values(table.columns).map((c) => columnSpecFromNode(c, isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const uniques = table.uniques.map((u) => ({
+		columns: u.columns,
+		...u.name !== void 0 ? { name: u.name } : {}
+	}));
+	const foreignKeys = table.foreignKeys.map((fk) => ({
+		columns: fk.columns,
+		references: {
+			table: fk.referencedTable,
+			columns: fk.referencedColumns
+		},
+		...fk.name !== void 0 ? { name: fk.name } : {},
+		...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+		...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+	}));
+	return {
+		columns,
+		...table.primaryKey ? { primaryKey: { columns: table.primaryKey.columns } } : {},
+		uniques,
+		foreignKeys
+	};
+}
+function issueConflict(kind, summary, location) {
+	return {
+		kind,
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function issueLocation(tableName, columnName) {
+	return columnName !== void 0 ? {
+		entityKind: "table",
+		entityName: tableName,
+		column: columnName
+	} : {
+		entityKind: "table",
+		entityName: tableName
+	};
+}
+/**
+* Conflict kind for a node kind that `recreateTableStrategy` absorbs for
+* every reachable production issue. Reaching `mapNodeIssueToCall` for one of
+* these means the recreate strategy didn't run — mirrors the legacy
+* `conflictKindForIssue` per-kind categorization.
+*/
+function absorbedConflictKind(nodeKind) {
+	switch (nodeKind) {
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.unique: return "indexIncompatible";
+		case RelationalSchemaNodeKind.foreignKey: return "foreignKeyConflict";
+		default: return "missingButNonAdditive";
+	}
+}
+/**
+* Builds the `CreateTableCall` + per-index `CreateIndexCall`s for a
+* newly-expected table. Reads only the table node's own children — indexes
+* (declared + FK-backing, deduped) are already merged and ordered at
+* derivation (`contractToSchemaIR`'s `convertTable`).
+*/
+function buildCreateTableCalls(table) {
+	const columns = Object.values(table.columns).map((c) => ddlColumnFromNode(c, isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const constraints = tableConstraintsFromNode(table, Object.values(table.columns).some((c) => isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const calls = [new CreateTableCall(table.name, columns, constraints.length > 0 ? constraints : void 0)];
+	for (const index of table.indexes) {
+		const indexName = index.name;
+		calls.push(new CreateIndexCall(table.name, indexName, index.columns ?? []));
+	}
+	return calls;
+}
+function mapTableIssue(issue) {
+	if (issueOutcome(issue) === "not-found") return ok(buildCreateTableCalls(blindCast(issue.expected)));
+	if (issueOutcome(issue) === "not-expected") {
+		const table = blindCast(issue.actual);
+		if (CONTROL_TABLE_NAMES.has(table.name)) return ok([]);
+		return ok([new DropTableCall(table.name)]);
+	}
+	return notOk(issueConflict("unsupportedOperation", `Unexpected table drift: ${issue.path.join("/")}`));
+}
+function mapColumnIssue(issue, ctx) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return notOk(issueConflict("unsupportedOperation", `Column issue has no table in its path: ${issue.path.join("/")}`));
+	if (issueOutcome(issue) === "not-found") {
+		const column = blindCast(issue.expected);
+		const table = ctx.expected.tables[tableName];
+		return ok([new AddColumnCall(tableName, columnSpecFromNode(column, table !== void 0 && isInlineAutoincrementPrimaryKeyNode(table, column)))]);
+	}
+	if (issueOutcome(issue) === "not-expected") return ok([new DropColumnCall(tableName, blindCast(issue.actual).name)]);
+	const expected = blindCast(issue.expected);
+	return notOk(issueConflict(sqlColumnTypesEqual(expected, blindCast(issue.actual)) ? "nullabilityConflict" : "typeMismatch", issue.path.join("/"), issueLocation(tableName, expected.name)));
+}
+function mapIndexIssue(issue) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return notOk(issueConflict("unsupportedOperation", `Index issue has no table in its path: ${issue.path.join("/")}`));
+	if (issueOutcome(issue) === "not-found") {
+		const index = blindCast(issue.expected);
+		const indexName = index.name;
+		return ok([new CreateIndexCall(tableName, indexName, index.columns ?? [])]);
+	}
+	if (issueOutcome(issue) === "not-expected") {
+		const indexName = blindCast(issue.actual).name;
+		return ok([new DropIndexCall(tableName, indexName)]);
+	}
+	return notOk(issueConflict("indexIncompatible", issue.path.join("/"), issueLocation(tableName)));
+}
+function mapNodeIssueToCall(issue, ctx) {
+	const node = issueNode(issue);
+	if (node === void 0) return notOk(issueConflict("unsupportedOperation", `Issue carries neither an expected nor an actual node: ${issue.path.join("/")}`));
+	switch (node.nodeKind) {
+		case RelationalSchemaNodeKind.table: return mapTableIssue(issue);
+		case RelationalSchemaNodeKind.column: return mapColumnIssue(issue, ctx);
+		case RelationalSchemaNodeKind.index: return mapIndexIssue(issue);
+		case RelationalSchemaNodeKind.columnDefault:
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.foreignKey:
+		case RelationalSchemaNodeKind.unique: return notOk(issueConflict(absorbedConflictKind(node.nodeKind), issue.path.join("/")));
+		case RelationalSchemaNodeKind.check: return notOk(issueConflict("unsupportedOperation", `The SQLite target does not support CHECK constraint DDL: ${issue.path.join("/")}`));
+		default: return notOk(issueConflict("unsupportedOperation", `Unhandled node kind: ${node.nodeKind}`));
+	}
+}
+function classifyCall(call) {
+	switch (call.factoryName) {
+		case "createTable": return "create-table";
+		case "addColumn": return "add-column";
+		case "createIndex": return "create-index";
+		case "dropColumn": return "drop-column";
+		case "dropIndex": return "drop-index";
+		case "dropTable": return "drop-table";
+		case "recreateTable": return null;
+		default: return null;
+	}
+}
+const DEFAULT_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive",
+	"data"
+] };
+function planIssues(options) {
+	const policyProvided = options.policy !== void 0;
+	const policy = options.policy ?? DEFAULT_POLICY;
+	const frameworkComponents = options.frameworkComponents ?? [];
+	const context = {
+		expected: options.expected ?? emptySchemaIR(),
+		actual: options.actual ?? emptySchemaIR(),
+		policy,
+		frameworkComponents,
+		types: sqlTypeLookupsOf(frameworkComponents),
+		statementColumns: options.statementColumns ?? {
+			convert: [],
+			backfill: []
+		},
+		takesTemporaryValue: options.takesTemporaryValue ?? (() => true),
+		originCodecId: options.originCodecId ?? (() => void 0)
+	};
+	const strategies = options.strategies ?? sqlitePlannerStrategies;
+	let remaining = options.issues;
+	const recipeCalls = [];
+	const bucketableCalls = [];
+	for (const strategy of strategies) {
+		const result = strategy(remaining, context);
+		if (result.kind === "match") {
+			remaining = result.issues;
+			if (result.recipe) recipeCalls.push(...result.calls);
+			else bucketableCalls.push(...result.calls);
+		}
+	}
+	const sorted = orderIssuesByDependencies(remaining);
+	const defaultCalls = [];
+	const conflicts = [];
+	for (const issue of sorted) {
+		const result = mapNodeIssueToCall(issue, context);
+		if (result.ok) defaultCalls.push(...result.value);
+		else conflicts.push(result.failure);
+	}
+	const allowed = policy.allowedOperationClasses;
+	let gatedRecipe = recipeCalls;
+	let gatedBucketable = bucketableCalls;
+	let gatedDefault = defaultCalls;
+	if (policyProvided) {
+		const sink = (acc) => (call) => {
+			if (allowed.includes(call.operationClass)) {
+				acc.push(call);
+				return;
+			}
+			conflicts.push(conflictForDisallowedCall(call, allowed));
+		};
+		const gatedRecipeBucket = [];
+		const gatedBucketableBucket = [];
+		const gatedDefaultBucket = [];
+		recipeCalls.forEach(sink(gatedRecipeBucket));
+		bucketableCalls.forEach(sink(gatedBucketableBucket));
+		defaultCalls.forEach(sink(gatedDefaultBucket));
+		gatedRecipe = gatedRecipeBucket;
+		gatedBucketable = gatedBucketableBucket;
+		gatedDefault = gatedDefaultBucket;
+	}
+	if (conflicts.length > 0) return notOk(conflicts);
+	const rebuiltIndexes = new Set(gatedRecipe.flatMap((call) => call instanceof RecreateTableCall ? call.indexes.map((index) => indexKey(call.tableName, index.name)) : []));
+	const bucketed = [...gatedDefault, ...gatedBucketable];
+	const addedBeforeIndexes = new Set(bucketed.flatMap((call) => call instanceof AddColumnCall ? [indexKey(call.tableName, call.columnName)] : []));
+	const indexesANewColumn = (call) => {
+		const live = context.actual.tables[call.tableName];
+		return live !== void 0 && call.columns.some((column) => live.columns[column] === void 0 && !addedBeforeIndexes.has(indexKey(call.tableName, column)));
+	};
+	const combined = bucketed.filter((call) => !(call instanceof CreateIndexCall) || !indexesANewColumn(call) || !rebuiltIndexes.has(indexKey(call.tableName, call.indexName)));
+	const byCategory = (cat) => combined.filter((c) => classifyCall(c) === cat);
+	return ok({ calls: [
+		...byCategory("create-table"),
+		...byCategory("add-column"),
+		...byCategory("create-index"),
+		...gatedRecipe,
+		...byCategory("drop-column"),
+		...byCategory("drop-index"),
+		...byCategory("drop-table")
+	] });
+}
+function indexKey(tableName, indexName) {
+	return JSON.stringify([tableName, indexName]);
+}
+function emptySchemaIR() {
+	return new SqlSchemaIR({ tables: {} });
+}
+function conflictForDisallowedCall(call, allowed) {
+	const summary = `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`;
+	const location = locationForCall(call);
+	return {
+		kind: conflictKindForCall(call),
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		refusedOperationClass: call.operationClass,
+		...location ? { location } : {}
+	};
+}
+function conflictKindForCall(call) {
+	switch (call.factoryName) {
+		case "createIndex":
+		case "dropIndex": return "indexIncompatible";
+		default: return "missingButNonAdditive";
+	}
+}
+function locationForCall(call) {
+	const location = {};
+	if ("tableName" in call) {
+		location.entityKind = "table";
+		location.entityName = call.tableName;
+	}
+	if ("columnName" in call) location.column = call.columnName;
+	if ("indexName" in call) location.index = call.indexName;
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function indexFindings(issues, outcome) {
+	return issues.flatMap((issue) => {
+		const node = issueNode(issue);
+		const tableName = issue.path[1];
+		if (node === void 0 || !SqlIndexIR.is(node) || tableName === void 0) return [];
+		return issueOutcome(issue) === outcome ? [{
+			issue,
+			index: node,
+			tableName
+		}] : [];
+	});
+}
+/**
+* An index on a renamed table whose wire name derives from the table name: the old and the new index share their content hash and differ in name.
+*/
+function renamedTableIndex(renamedTables) {
+	return (old, replacement) => {
+		const oldWire = parseWireName(old.index.name);
+		const replacementWire = parseWireName(replacement.index.name);
+		return renamedTables.has(old.tableName) && old.tableName === replacement.tableName && oldWire !== void 0 && oldWire.hash === replacementWire?.hash && old.index.name !== replacement.index.name;
+	};
+}
+/**
+* An index on the renamed column whose wire name derives from the column name: after the rename
+* the old and the new index cover the same columns on the same table and differ in name.
+*/
+function renamedColumnIndex(table, column) {
+	return (old, replacement) => old.tableName === table && replacement.tableName === table && old.index.name !== replacement.index.name && old.index.expression === void 0 && old.index.where === void 0 && (old.index.columns ?? []).includes(column) && old.index.unique === replacement.index.unique && isArrayEqual(old.index.columns ?? [], replacement.index.columns ?? []);
+}
+/**
+* An index on the same table whose new name SQLite takes for the old one, as after a table renamed by hand. Its content is not compared: the old index must be dropped before the new one can be created whatever either defines, and the new one is created from its own definition.
+*/
+const indexNameCaseChange = (old, replacement) => old.tableName === replacement.tableName && old.index.name !== replacement.index.name && sqliteIdentifiersCollide(old.index.name, replacement.index.name);
+/**
+* Pairs each index the plan drops with the index that replaces it, and plans every paired drop before every paired create. SQLite cannot rename an index, and it compares index names without regard to the case of ASCII letters, so a replacement whose name differs from the old one only in that case would otherwise collide with it. The paired issues are returned as consumed so the ordinary diff does not plan them again.
+*/
+function pairIndexReplacements(issues, matches) {
+	const missing = indexFindings(issues, "not-found");
+	const pairs = indexFindings(issues, "not-expected").flatMap((old) => {
+		const replacement = missing.find((candidate) => matches(old, candidate));
+		if (replacement === void 0) return [];
+		missing.splice(missing.indexOf(replacement), 1);
+		return [{
+			old,
+			replacement
+		}];
+	});
+	const replacements = pairs.map(({ old, replacement }) => ({
+		drop: new DropIndexCall(old.tableName, old.index.name),
+		create: new CreateIndexCall(replacement.tableName, replacement.index.name, replacement.index.columns ?? [])
+	}));
+	return {
+		replacements,
+		calls: indexReplacementCalls(replacements),
+		consumed: new Set(pairs.flatMap(({ old, replacement }) => [old.issue, replacement.issue]))
+	};
+}
+/**
+* The tables of a SQLite schema. SQLite has one namespace, so the namespace id is ignored, and it
+* compares table and column names without regard to the case of ASCII letters.
+*/
+function sqliteSchemaTables(schema) {
+	const hasTable = (_namespaceId, table) => Object.hasOwn(schema.tables, table);
+	return {
+		hasTable,
+		hasColumn: (_namespaceId, table, column) => Object.hasOwn(schema.tables[table]?.columns ?? {}, column),
+		tablesNamed: (_namespaceId, table) => Object.keys(schema.tables).filter((existing) => sqliteIdentifiersCollide(existing, table)),
+		columnsNamed: (_namespaceId, table, column) => Object.keys(schema.tables[table]?.columns ?? {}).filter((existing) => sqliteIdentifiersCollide(existing, column)),
+		namespacesWithTable: (table) => hasTable(UNBOUND_NAMESPACE_ID, table) ? [UNBOUND_NAMESPACE_ID] : [],
+		hasNamespace: (namespaceId) => namespaceId === UNBOUND_NAMESPACE_ID
+	};
+}
+function rewriteRefs(refs, rewrite) {
+	return refs?.map(rewrite);
+}
+/**
+* Rewrites the step of `kind` and `id` in a ref that runs through the given table, and the table
+* step itself when `kind` is the table kind.
+*/
+function stepRewrite(tableName, kind, fromId, toId) {
+	return (ref) => {
+		const tableStep = ref[1];
+		if (tableStep?.nodeKind !== RelationalSchemaNodeKind.table || tableStep.id !== tableName) return ref;
+		return ref.map((step, index) => index >= 1 && step.nodeKind === kind && step.id === fromId ? {
+			nodeKind: kind,
+			id: toId
+		} : step);
+	};
+}
+/**
+* An index whose definition carries SQL text, an expression or a predicate, keeps its columns as
+* they are: a column named inside the text cannot be renamed here, so the diff plans the index.
+*/
+function withIndex(index, name, rewrite, columnName) {
+	const columnsFollow = index.expression === void 0 && index.where === void 0;
+	const base = {
+		naming: name === index.name ? namingOf(index.name, index.prefix) : namingOfLiveName(name),
+		where: index.where,
+		unique: index.unique,
+		partial: index.partial,
+		type: index.type,
+		options: index.options,
+		annotations: index.annotations,
+		dependsOn: rewriteRefs(index.dependsOn, rewrite)
+	};
+	return new SqlIndexIR(index.expression !== void 0 ? {
+		...base,
+		expression: index.expression
+	} : {
+		...base,
+		columns: (index.columns ?? []).map(columnsFollow ? columnName : (c) => c)
+	});
+}
+function rebuildTable(table, edit, rewrite) {
+	const { primaryKey } = table;
+	const { columnName } = edit;
+	return new SqlTableIR({
+		name: edit.name,
+		columns: Object.fromEntries(Object.values(table.columns).map((column) => {
+			const name = columnName(column.name);
+			return [name, name === column.name ? column : column.withName(name)];
+		})),
+		...ifDefined("primaryKey", primaryKey === void 0 ? void 0 : new PrimaryKey({
+			columns: primaryKey.columns.map(columnName),
+			...ifDefined("name", primaryKey.name),
+			...ifDefined("dependsOn", rewriteRefs(primaryKey.dependsOn, rewrite))
+		})),
+		uniques: table.uniques.map((unique) => new SqlUniqueIR({
+			columns: unique.columns.map(columnName),
+			...ifDefined("name", unique.name),
+			...ifDefined("annotations", unique.annotations),
+			...ifDefined("dependsOn", rewriteRefs(unique.dependsOn, rewrite))
+		})),
+		foreignKeys: table.foreignKeys.map((fk) => new SqlForeignKeyIR({
+			columns: fk.columns.map(columnName),
+			referencedTable: edit.referencedTable(fk),
+			referencedColumns: edit.referencedColumns(fk),
+			...ifDefined("referencedSchema", fk.referencedSchema),
+			...ifDefined("name", fk.name),
+			...ifDefined("onDelete", fk.onDelete),
+			...ifDefined("onUpdate", fk.onUpdate),
+			...ifDefined("annotations", fk.annotations),
+			...ifDefined("resolvedReferencedNamespace", fk.resolvedReferencedNamespace),
+			...ifDefined("dependsOn", rewriteRefs(fk.dependsOn, rewrite))
+		})),
+		indexes: table.indexes.map((index) => withIndex(index, edit.indexName(index), rewrite, columnName)),
+		...ifDefined("checks", table.checks?.map((check) => new SqlCheckConstraintIR({
+			naming: namingOf(check.name, check.prefix),
+			expression: check.expression,
+			dependsOn: rewriteRefs(check.dependsOn, rewrite)
+		}))),
+		...ifDefined("annotations", table.annotations)
+	});
+}
+/** Rebuilds every table: `editFor` returns the edit for a table, or `undefined` to keep it. */
+function mapTables(schema, rewrite, editFor) {
+	return new SqlSchemaIR({
+		tables: Object.fromEntries(Object.values(schema.tables).map((table) => {
+			const rebuilt = rebuildTable(table, {
+				name: table.name,
+				columnName: (column) => column,
+				referencedTable: (fk) => fk.referencedTable,
+				referencedColumns: (fk) => fk.referencedColumns,
+				indexName: (index) => index.name,
+				...editFor(table)
+			}, rewrite);
+			return [rebuilt.name, rebuilt];
+		})),
+		...ifDefined("annotations", schema.annotations)
+	});
+}
+/**
+* The schema with one table under its new name. Foreign keys anywhere that reference the table
+* follow it, and every dependency that names it moves with it. Object names do not change. An
+* unnamed primary key, unique constraint or foreign key stays unnamed: SQLite gives such a
+* constraint no name, so an introspected schema has none either, and the planner never renames
+* one.
+*/
+function renameTableInSqliteSchema(schema, rename) {
+	const { from, to } = rename;
+	return mapTables(schema, stepRewrite(from, RelationalSchemaNodeKind.table, from, to), (table) => ({
+		...table.name === from ? { name: to } : {},
+		referencedTable: (fk) => fk.referencedTable === from ? to : fk.referencedTable
+	}));
+}
+/**
+* The schema with one column under its new name. The table's primary key, unique constraints,
+* foreign keys and plain column indexes name it under the new name, foreign keys anywhere that
+* reference it follow it, and every dependency that names it moves with it. An index with an
+* expression or a predicate keeps its SQL text, and index names do not change, as in SQLite.
+*/
+function renameColumnInSqliteSchema(schema, rename) {
+	const { table: tableName, from, to } = rename;
+	const rewrite = stepRewrite(tableName, RelationalSchemaNodeKind.column, `column:${from}`, `column:${to}`);
+	const renamed = (column) => column === from ? to : column;
+	return mapTables(schema, rewrite, (table) => ({
+		...table.name === tableName ? { columnName: renamed } : {},
+		referencedColumns: (fk) => fk.referencedTable === tableName ? fk.referencedColumns.map(renamed) : fk.referencedColumns
+	}));
+}
+function replaceIndex(schema, replacement) {
+	const { tableName, indexName: oldIndexName } = replacement.drop;
+	const newIndexName = replacement.create.indexName;
+	return mapTables(schema, stepRewrite(tableName, RelationalSchemaNodeKind.index, `index:${oldIndexName}`, `index:${newIndexName}`), (table) => table.name === tableName ? { indexName: (index) => index.name === oldIndexName ? newIndexName : index.name } : void 0);
+}
+/** The working schema of a plan or a migration, starting from `initial`. */
+function createWorkingSchema(initial) {
+	return new WorkingSchemaImpl(initial);
+}
+var WorkingSchemaImpl = class {
+	#current;
+	constructor(initial) {
+		this.#current = initial;
+	}
+	get current() {
+		return this.#current;
+	}
+	apply(call) {
+		const renamed = call instanceof RenameColumnCall ? renameColumnInSqliteSchema(this.#current, {
+			table: call.tableName,
+			from: call.oldColumnName,
+			to: call.columnName
+		}) : renameTableInSqliteSchema(this.#current, {
+			from: call.oldTableName,
+			to: call.tableName
+		});
+		this.#current = call.indexReplacements.reduce(replaceIndex, renamed);
+	}
+};
+/** The SQL a user runs against the database to rename the table by hand. */
+function renameTableByHandStatements(rename) {
+	return renameTableSteps(rename.from, rename.to).map((renameStep) => renameStep.sql);
+}
+/** The `renameTable` call a user writes in `migration.ts` for `rename`; SQLite has no namespaces. */
+function renderRenameTableCall(rename) {
+	return new RenameTableCall(rename.from, rename.to, []).renderTypeScript();
+}
+/** How a user renames a table by hand on SQLite. */
+const sqliteTableRenameByHand = {
+	renderTableRename: renderRenameTableCall,
+	tableRenameByHand: renameTableByHandStatements
+};
+/**
+* The call that renames a table, carrying as companions a drop and a create under the new name of
+* each index whose wire name derives from the old table name, since SQLite cannot rename an index.
+* `previous` is the schema with the table under its old name; the renamed copy is diffed against
+* `contract`. SQLite names no primary key, unique constraint or foreign key the contract leaves
+* unnamed, so those need nothing.
+*/
+function sqliteTableRenameCall(input) {
+	const { from, to } = input.rename;
+	const { issues } = buildSqlitePlanDiff({
+		contract: input.contract,
+		actualSchema: renameTableInSqliteSchema(input.previous, {
+			from,
+			to
+		}),
+		frameworkComponents: input.frameworkComponents
+	});
+	const { replacements } = pairIndexReplacements(coalesceSubtreeIssues(issues), renamedTableIndex(/* @__PURE__ */ new Set([to])));
+	return new RenameTableCall(from, to, replacements);
+}
+/**
+* The call that renames a column, carrying as companions a drop and a create under the new name of
+* each index on the column whose wire name derives from the column name, since SQLite cannot rename
+* an index and keeps the old name when it renames the column. `previous` is the schema with the
+* column under its old name; the renamed copy is diffed against `contract`.
+*/
+function sqliteColumnRenameCall(input) {
+	const { table, from, to } = input.rename;
+	const { issues } = buildSqlitePlanDiff({
+		contract: input.contract,
+		actualSchema: renameColumnInSqliteSchema(input.previous, {
+			table,
+			from,
+			to
+		}),
+		frameworkComponents: input.frameworkComponents
+	});
+	const { replacements } = pairIndexReplacements(coalesceSubtreeIssues(issues), renamedColumnIndex(table, to));
+	return new RenameColumnCall(table, from, to, replacements);
+}
+/**
+* Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
+* generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
+* SQLite literal, so both user-authored migrations and renderer-generated
+* scaffolds can extend `SqliteMigration` directly without redeclaring
+* target-local identity.
+*
+* The constructor materializes a single SQLite `SqlControlAdapter` from
+* `stack.adapter.create(stack)` and stores it; the protected instance methods
+* forward to the corresponding `*Call` with that stored adapter, so user
+* migrations can write `this.createTable({...})` without threading the adapter
+* through every call.
+*
+* Binds the framework base's `Start` / `End` contract generics so a subclass
+* that assigns its snapshot-store `contract.json` imports to
+* `startContractJson` / `endContractJson` gets fully-typed view accessors:
+* `this.endContract` is a `SqliteContractView<End>`
+* (sole namespace unwrapped to the root — `this.endContract.table.<name>`),
+* built lazily from the JSON fields via the shared `MigrationContractViews`
+* helper. Mirrors `MongoMigration`'s view getters; the framework base derives
+* `describe()` from the same JSON.
+*/
+var SqliteMigration = class extends Migration {
+	targetId = "sqlite";
+	/**
+	* Materialized SQLite control adapter, created once per migration
+	* instance from the injected stack. `undefined` only when the migration
+	* was instantiated without a stack (test fixtures); `controlAdapterFor`
+	* throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.
+	*/
+	controlAdapter;
+	#endView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	/** The rename calls this read of `operations` has made so far, in order. */
+	#renames = [];
+	#startView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
+	}
+	frameworkComponents() {
+		const stack = this.stack;
+		if (stack === void 0) return [];
+		return [
+			stack.target,
+			...stack.adapter === void 0 ? [] : [stack.adapter],
+			...stack.extensions
+		];
+	}
+	/**
+	* Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming
+	* `operation` when the migration was constructed without a `ControlStack`.
+	* Single home for the null-check that every DDL/DML method shares.
+	*/
+	controlAdapterFor(operation) {
+		if (!this.controlAdapter) throw errorSqliteMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	/**
+	* The typed SQLite view over this migration's end-state contract — sole
+	* namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+	* Throws if no `endContractJson` was provided.
+	*/
+	get endContract() {
+		return this.#endView.endContract;
+	}
+	/**
+	* The typed SQLite view over this migration's start-state contract, or
+	* `null` for a baseline migration (no `startContractJson`).
+	*/
+	get startContract() {
+		return this.#startView.startContract;
+	}
+	createTable(options) {
+		return new CreateTableCall(options.table, options.columns, options.constraints).toOp(this.controlAdapterFor("createTable"));
+	}
+	dropTable(options) {
+		return new DropTableCall(options.table).toOp(this.controlAdapterFor("dropTable"));
+	}
+	/**
+	* Emit the operations that rename a table: the table rename, then a drop and a create under the
+	* new name of each index whose name was derived from the old table name. The old name is resolved
+	* against the schema as this migration's earlier `renameTable` calls leave it, and the new name
+	* against the end contract. Spread the result into `operations`:
+	* `...this.renameTable({ table: 'userProfile', to: 'UserProfile' })`. Throws
+	* `MIGRATION.TABLE_RENAME_UNMATCHED` when the table does not exist at that point of the migration
+	* or the end contract lacks the new name.
+	*/
+	renameTable(options) {
+		const adapter = this.controlAdapterFor("renameTable");
+		const rename = {
+			namespaceId: void 0,
+			from: options.table,
+			to: options.to
+		};
+		const startContract = this.startContract;
+		if (startContract === null) throw unmatchedTableRename(rename, "the migration has no start contract");
+		const current = this.schemaAfterRenames(startContract);
+		const endContract = this.endContract;
+		const resolved = resolveTableRenameAgainst(sqliteSchemaTables(current), endContract, rename);
+		if (!resolved.ok) throw resolved.failure;
+		const call = sqliteTableRenameCall({
+			previous: current,
+			contract: endContract,
+			rename: resolved.value,
+			frameworkComponents: this.frameworkComponents()
+		});
+		this.#renames.push(call);
+		return call.toOps(adapter);
+	}
+	/**
+	* Emit the operations that rename a column: the column rename, then a drop and a create under
+	* the new name of each index on the column whose name was derived from the old column name. The
+	* column is resolved against the schema as this migration's earlier rename calls leave it, so a
+	* column of a table an earlier `renameTable` renamed is named on the table's new name. Spread the
+	* result into `operations`: `...this.renameColumn({ table: 'User', column: 'name', to:
+	* 'fullName' })`. Throws `MIGRATION.COLUMN_RENAME_UNMATCHED` when the table or column does not
+	* exist at that point of the migration, the table already has the new column, or the end
+	* contract lacks it.
+	*/
+	renameColumn(options) {
+		const adapter = this.controlAdapterFor("renameColumn");
+		const rename = {
+			namespaceId: void 0,
+			table: options.table,
+			from: options.column,
+			to: options.to
+		};
+		const startContract = this.startContract;
+		if (startContract === null) throw unmatchedColumnRename(rename, "the migration has no start contract");
+		const current = this.schemaAfterRenames(startContract);
+		const resolved = resolveColumnRenameAgainst(sqliteSchemaTables(current), this.endContract, rename);
+		if (!resolved.ok) throw resolved.failure;
+		const call = sqliteColumnRenameCall({
+			previous: current,
+			contract: this.endContract,
+			rename: resolved.value,
+			frameworkComponents: this.frameworkComponents()
+		});
+		this.#renames.push(call);
+		return call.toOps(adapter);
+	}
+	/** The start contract's schema with this read's rename calls applied in order. */
+	schemaAfterRenames(startContract) {
+		const working = createWorkingSchema(sqliteContractToSchema(startContract, sqlTypeLookupsOf(this.frameworkComponents())));
+		for (const call of this.#renames) working.apply(call);
+		return working.current;
+	}
+	beginOperationsRead() {
+		this.#renames = [];
+	}
+	addColumn(options) {
+		return new AddColumnCall(options.table, columnSpecOf(options.column, "addColumn", options.table)).toOp(this.controlAdapterFor("addColumn"));
+	}
+	dropColumn(options) {
+		return new DropColumnCall(options.table, options.column).toOp(this.controlAdapterFor("dropColumn"));
+	}
+	createIndex(options) {
+		return new CreateIndexCall(options.table, options.index, options.columns).toOp(this.controlAdapterFor("createIndex"));
+	}
+	dropIndex(options) {
+		return new DropIndexCall(options.table, options.index).toOp(this.controlAdapterFor("dropIndex"));
+	}
+	recreateTable(options) {
+		const { copyExpressions, temporaryValues, ...args } = options;
+		return new RecreateTableCall({
+			...args,
+			contractTable: {
+				...options.contractTable,
+				columns: options.contractTable.columns.map((column) => columnSpecOf(column, "recreateTable", options.tableName))
+			},
+			...ifDefined("copyExpressions", copyExpressions === void 0 ? void 0 : copyExpressionSlotsOf(copyExpressions, options.tableName)),
+			...ifDefined("temporaryValues", temporaryValues === void 0 ? void 0 : copyExpressionSlotsOf(temporaryValues, options.tableName, "temporaryValues"))
+		}).toOp(this.controlAdapterFor("recreateTable"));
+	}
+};
+function columnDefaultOf(columnDefault, what) {
+	return columnDefault.kind === "function" ? {
+		kind: "function",
+		expression: sqlTextOf(columnDefault.expression, what)
+	} : columnDefault;
+}
+function columnSpecOf(column, operation, table) {
+	const { default: columnDefault, ...rest } = column;
+	const what = `${operation} ${JSON.stringify(table)}.${JSON.stringify(column.name)} default`;
+	return {
+		...rest,
+		...ifDefined("default", columnDefault === void 0 ? void 0 : columnDefaultOf(columnDefault, what))
+	};
+}
+function copyExpressionSlotsOf(copyExpressions, table, option = "copyExpressions") {
+	return Object.fromEntries(Object.entries(copyExpressions).map(([column, expression]) => [column, {
+		kind: "sql",
+		sql: sqlTextOf(expression, `recreateTable ${JSON.stringify(table)} ${option}.${column}`)
+	}]));
+}
+//#endregion
+export { sqliteSchemaTables as _, createWorkingSchema as a, verifySqliteDatabaseSchema as b, issueNode as c, renameTableByHandStatements as d, renderRenameTableCall as f, sqlitePlannerStrategies as g, sqliteContractToSchema as h, conflictForDisallowedCall as i, pairIndexReplacements as l, sqliteColumnRenameCall as m, buildSqlitePlanDiff as n, diffSqliteSchema as o, sqliteActualSchema as p, coalesceSubtreeIssues as r, indexNameCaseChange as s, SqliteMigration as t, planIssues as u, sqliteTableRenameByHand as v, sqliteTableRenameCall as y };
+
+//# sourceMappingURL=sqlite-migration-BAdSmooi-iWFVQgGV.mjs.map