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

package/dist/op-factory-call-emj9Xp05-BFLkxrAK.mjs

@@ -0,0 +1,1414 @@
+import { n as sqliteError } from "./errors-DnR-sMHS-D_gh214a.mjs";
+import { a as tableExistsAst, i as indexExistsAst, n as columnNameTakenAst, o as tableNameTakenAst, r as createTable, t as columnExistsAst } from "./ddl-CX4tAZ-y-Bng-4PWC.mjs";
+import { n as escapeLiteral, r as quoteIdentifier, t as SQLITE_QUOTING } from "./sql-utils-XGT5Esi2-Zr2mqJf8.mjs";
+import { r as stripOuterParens } from "./default-normalizer-DGMXypHg-CPf7oyZA.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-CIQ789Gc-Cug2V5g5.mjs";
+import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, opaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { assertNever } from "@prisma/orm-framework/utils/internal-error";
+import "@prisma/orm-family-sql/contract/data-type";
+import { type } from "arktype";
+import { expectAbsent, expectPresent, issueOutcome } from "@prisma/orm-framework/components/control";
+import { checkSqlExpressionText, convertedColumnMeta, createSqlTextSources, isUnfilledSlot, requiredColumnMeta, slotSource, sqlOfSlot } from "@prisma/orm-family-sql/family/control";
+import { RelationalSchemaNodeKind, sqlColumnTypesEqual } from "@prisma/orm-family-sql/schema-ir/types";
+import { errorMigrationOperationOptionRemoved, unfilledPlaceholderOperation } from "@prisma/orm-framework/errors/migration";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+import { TsExpression, jsonToTsSource, tsArraySource, tsObjectSource, tsQuotedTextSource } from "@prisma/orm-framework/ts-render";
+//#region ../../../3-targets/sqlite/1-target/dist/op-factory-call-emj9Xp05.mjs
+function foldAsciiLetters(identifier) {
+	return identifier.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+/**
+* Whether SQLite takes two identifiers for the same name. It compares table and index names without regard to the case of ASCII letters, and compares every other character exactly.
+*/
+function sqliteIdentifiersCollide(left, right) {
+	return foldAsciiLetters(left) === foldAsciiLetters(right);
+}
+function step(description, sql, params, expectation) {
+	return {
+		description,
+		sql,
+		...ifDefined("params", params),
+		...ifDefined("expectation", expectation)
+	};
+}
+/** The text a `DdlColumn`'s type ends with when the column is SQLite's inline `INTEGER PRIMARY KEY AUTOINCREMENT`. */
+const INLINE_AUTOINCREMENT_PRIMARY_KEY = " PRIMARY KEY AUTOINCREMENT";
+/** The DDL default of a contract default: `autoincrement()` is written as part of the column's type instead. */
+function sqliteDefaultToDdlColumnDefault(columnDefault) {
+	if (!columnDefault) return void 0;
+	switch (columnDefault.kind) {
+		case "literal": return new LiteralColumnDefault(columnDefault.value);
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return void 0;
+			return new FunctionColumnDefault(opaqueSql(columnDefault.expression));
+		default: {
+			const exhaustive = columnDefault;
+			return assertNever(exhaustive, `sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast(exhaustive).kind}"`);
+		}
+	}
+}
+/**
+* A column spec an earlier version wrote carries its default as SQL text in `defaultSql`, empty when it has none.
+*/
+function refuseEarlierColumnSpecs(operation, tableName, columns) {
+	const earlier = columns.find((column) => Object.hasOwn(column, "defaultSql"));
+	if (earlier === void 0) return;
+	throw errorMigrationOperationOptionRemoved({
+		operation,
+		option: "defaultSql",
+		subject: `column ${JSON.stringify(earlier.name)} of table ${JSON.stringify(tableName)}`,
+		rewrite: "Write the column's default as `default: { kind: 'literal', value }` or `default: { kind: 'function', expression }`, with the column's `codecRef`, in place of `defaultSql`, and delete an empty `defaultSql`.",
+		upgradeEntry: "migration-ts-column-defaults"
+	});
+}
+/** The `DEFAULT …` clause the adapter writes for a column spec, `''` when it has none. */
+function renderSpecDefault$1(column, tableName, lowerer) {
+	const ddlDefault = column.inlineAutoincrementPrimaryKey ? void 0 : sqliteDefaultToDdlColumnDefault(column.default);
+	return lowerer.renderColumnDefault(new DdlColumn({
+		name: column.name,
+		type: column.typeSql,
+		...ifDefined("default", ddlDefault),
+		...ifDefined("codecRef", column.codecRef)
+	}), tableName);
+}
+/**
+* Renders a single column's inline DDL fragment within a `CREATE TABLE`
+* statement. Honours the `inlineAutoincrementPrimaryKey` flag — SQLite
+* treats `INTEGER PRIMARY KEY AUTOINCREMENT` as a special form that aliases
+* `rowid`, and the column must not carry a `DEFAULT` or repeat `NOT NULL`.
+*/
+function renderColumnDefinition(column, defaultClause) {
+	const parts = [quoteIdentifier(column.name), column.typeSql];
+	if (column.inlineAutoincrementPrimaryKey) parts.push("PRIMARY KEY AUTOINCREMENT");
+	else {
+		if (defaultClause) parts.push(defaultClause);
+		if (!column.nullable) parts.push("NOT NULL");
+	}
+	return parts.join(" ");
+}
+/**
+* Renders an inline FOREIGN KEY constraint clause for a `CREATE TABLE`
+* body. Every `SqliteForeignKeySpec` is constraint-bearing by construction
+* (`tableSpecFromNode` only ever builds specs from schema-IR FK nodes, which
+* are themselves constraint-only — a non-constraint FK contributes no node).
+*/
+function renderForeignKeyClause(fk) {
+	let sql = `${fk.name ? `CONSTRAINT ${quoteIdentifier(fk.name)} ` : ""}FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${quoteIdentifier(fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (fk.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[fk.onDelete]}`;
+	if (fk.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[fk.onUpdate]}`;
+	return sql;
+}
+function text(value) {
+	return `'${escapeLiteral(value)}'`;
+}
+function columnRow(column) {
+	return `(${text(column.name)}, ${text(column.typeSql.toLowerCase())}, ${column.notNull ? 1 : 0}, ${column.primaryKeyPosition})`;
+}
+/** Checks that the table has exactly these columns, each with its type, nullability and primary key position. */
+function tableColumnsCheck(tableName, columns) {
+	const info = `pragma_table_info(${text(tableName)})`;
+	return {
+		description: `verify table "${tableName}" has exactly its columns`,
+		sql: `SELECT (SELECT COUNT(*) FROM ${info}) = ${columns.length} AND (SELECT COUNT(*) FROM ${info} WHERE (name, LOWER(type), "notnull", pk) IN (VALUES ${columns.map(columnRow).join(", ")})) = ${columns.length}`
+	};
+}
+/** Checks the column's type and nullability. */
+function columnShapeCheck(tableName, column) {
+	return {
+		description: `verify column "${column.name}" on "${tableName}" has type ${column.typeSql} and ${column.notNull ? "is required" : "is optional"}`,
+		sql: `SELECT COUNT(*) > 0 FROM pragma_table_info(${text(tableName)}) WHERE name = ${text(column.name)} AND LOWER(type) = ${text(column.typeSql.toLowerCase())} AND "notnull" = ${column.notNull ? 1 : 0}`
+	};
+}
+/** Checks that the index is on the table, covers exactly these columns in this order, and is unique or not. */
+function indexDefinitionCheck(tableName, indexName, columns, unique) {
+	const positions = columns.map((column, seqno) => `(${seqno}, ${text(column)})`).join(", ");
+	const info = `pragma_index_info(${text(indexName)})`;
+	return {
+		description: `verify index "${indexName}" on "${tableName}" covers (${columns.join(", ")})`,
+		sql: `SELECT EXISTS (SELECT 1 FROM pragma_index_list(${text(tableName)}) WHERE name = ${text(indexName)} AND "unique" = ${unique ? 1 : 0}) AND (SELECT COUNT(*) FROM ${info}) = ${columns.length} AND (SELECT COUNT(*) FROM ${info} WHERE (seqno, name) IN (VALUES ${positions})) = ${columns.length}`
+	};
+}
+function addColumnExecuteSql(tableName, column, defaultClause) {
+	return [
+		`ALTER TABLE ${quoteIdentifier(tableName)}`,
+		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
+		defaultClause,
+		column.nullable ? "" : "NOT NULL"
+	].filter(Boolean).join(" ");
+}
+function dropColumnExecuteSql(tableName, columnName) {
+	return `ALTER TABLE ${quoteIdentifier(tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`;
+}
+async function addColumn(tableName, column, lowerer) {
+	refuseEarlierColumnSpecs("addColumn", tableName, [column]);
+	const defaultClause = await renderSpecDefault$1(column, tableName, lowerer);
+	const checks = columnExistsAst(tableName, column.name);
+	const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+	const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+	return {
+		id: `column.${tableName}.${column.name}`,
+		label: `Add column ${column.name} on ${tableName}`,
+		summary: `Adds column ${column.name} on ${tableName}`,
+		operationClass: "additive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", column.name, tableName)
+		},
+		precheck: [step(`ensure column "${column.name}" is missing`, absent.sql, absent.params, expectAbsent(`column "${column.name}" on "${tableName}"`))],
+		execute: [step(`add column "${column.name}"`, addColumnExecuteSql(tableName, column, defaultClause))],
+		postcheck: [step(`verify column "${column.name}" exists`, present.sql, present.params, expectPresent(`column "${column.name}" on "${tableName}"`)), columnShapeCheck(tableName, {
+			name: column.name,
+			typeSql: column.typeSql,
+			notNull: !column.nullable
+		})]
+	};
+}
+function renameColumnExecuteSql(tableName, fromName, toName) {
+	return `ALTER TABLE ${quoteIdentifier(tableName)} RENAME COLUMN ${quoteIdentifier(fromName)} TO ${quoteIdentifier(toName)}`;
+}
+/**
+* Renames a column. SQLite updates the indexes, foreign keys and triggers that name it, and keeps
+* index names. SQLite takes names that differ only in case for the same name, so the new name
+* must be free whatever its case, except in a rename that only changes case, which SQLite performs
+* in one statement.
+*/
+function renameColumnOperationId(tableName, fromName) {
+	return `renameColumn.${tableName}.${fromName}`;
+}
+async function renameColumn(tableName, fromName, toName, lowerer) {
+	const fromChecks = columnExistsAst(tableName, fromName);
+	const toChecks = columnExistsAst(tableName, toName);
+	const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.columnPresent());
+	const onlyCase = sqliteIdentifiersCollide(fromName, toName);
+	const toAbsent = await lowerer.lowerToExecuteRequest(onlyCase ? toChecks.columnAbsent() : columnNameTakenAst(tableName, toName).nameFree());
+	const toPresent = await lowerer.lowerToExecuteRequest(toChecks.columnPresent());
+	const fromAbsent = await lowerer.lowerToExecuteRequest(fromChecks.columnAbsent());
+	return {
+		id: renameColumnOperationId(tableName, fromName),
+		label: `Rename column ${fromName} on ${tableName} to ${toName}`,
+		summary: `Renames column ${fromName} on ${tableName} to ${toName}, keeping its values`,
+		operationClass: "widening",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", toName, tableName)
+		},
+		precheck: [step(`ensure column "${fromName}" exists on "${tableName}"`, fromPresent.sql, fromPresent.params, expectPresent(`column "${fromName}" on "${tableName}"`)), step(`ensure column "${toName}" does not exist on "${tableName}"`, toAbsent.sql, toAbsent.params, expectAbsent(onlyCase ? `column "${toName}" on "${tableName}"` : `a column named "${toName}" on "${tableName}" in any case`))],
+		execute: [step(`rename column "${fromName}" on "${tableName}" to "${toName}"`, renameColumnExecuteSql(tableName, fromName, toName))],
+		postcheck: [step(`verify column "${toName}" exists on "${tableName}"`, toPresent.sql, toPresent.params, expectPresent(`column "${toName}" on "${tableName}"`)), step(`verify column "${fromName}" no longer exists on "${tableName}"`, fromAbsent.sql, fromAbsent.params, expectAbsent(`column "${fromName}" on "${tableName}"`))]
+	};
+}
+function buildCreateIndexSql(tableName, indexName, columns, unique = false) {
+	return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)} (${columns.map(quoteIdentifier).join(", ")})`;
+}
+function buildDropIndexSql(indexName) {
+	return `DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`;
+}
+async function tableExistsSteps(lowerer, tableName) {
+	const checks = tableExistsAst(tableName);
+	return {
+		present: await lowerer.lowerToExecuteRequest(checks.tablePresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.tableAbsent())
+	};
+}
+/**
+* Renders the body of a `CREATE TABLE <name> ( … )` statement from a flat
+* `SqliteTableSpec`. SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT` form is
+* inline on the column; the table-level PRIMARY KEY clause is emitted only
+* when no column carries `inlineAutoincrementPrimaryKey`.
+*/
+function renderCreateTableSql(tableName, spec, defaultClauses) {
+	const columnDefs = spec.columns.map((column, index) => renderColumnDefinition(column, defaultClauses[index] ?? ""));
+	const constraintDefs = [];
+	const hasInlinePk = spec.columns.some((c) => c.inlineAutoincrementPrimaryKey);
+	if (spec.primaryKey && !hasInlinePk) constraintDefs.push(`PRIMARY KEY (${spec.primaryKey.columns.map(quoteIdentifier).join(", ")})`);
+	for (const u of spec.uniques ?? []) {
+		const name = u.name ? `CONSTRAINT ${quoteIdentifier(u.name)} ` : "";
+		constraintDefs.push(`${name}UNIQUE (${u.columns.map(quoteIdentifier).join(", ")})`);
+	}
+	for (const fk of spec.foreignKeys ?? []) {
+		const clause = renderForeignKeyClause(fk);
+		if (clause) constraintDefs.push(clause);
+	}
+	const allDefs = [...columnDefs, ...constraintDefs];
+	return `CREATE TABLE ${quoteIdentifier(tableName)} (\n  ${allDefs.join(",\n  ")}\n)`;
+}
+function renameTableViaName(toName) {
+	return `_prisma_rename_${toName}`;
+}
+function renameChangesOnlyCase(fromName, toName) {
+	return sqliteIdentifiersCollide(fromName, toName);
+}
+/**
+* SQLite takes names that differ only in the case of ASCII letters for the
+* same name, so such a rename (`userProfile` to `UserProfile`) is refused as
+* "already exists" when done in one statement. It goes through a temporary name.
+*/
+function renameTableSteps(fromName, toName) {
+	const from = quoteIdentifier(fromName);
+	const to = quoteIdentifier(toName);
+	if (!renameChangesOnlyCase(fromName, toName)) return [step(`rename table "${fromName}" to "${toName}"`, `ALTER TABLE ${from} RENAME TO ${to}`)];
+	const viaName = renameTableViaName(toName);
+	const via = quoteIdentifier(viaName);
+	return [step(`rename table "${fromName}" to "${viaName}" (SQLite table names are case-insensitive)`, `ALTER TABLE ${from} RENAME TO ${via}`), step(`rename table "${viaName}" to "${toName}"`, `ALTER TABLE ${via} RENAME TO ${to}`)];
+}
+/** The table a rebuild of `tableName` creates, copies into, and renames to `tableName`. */
+function rebuiltTableName(tableName) {
+	return `_prisma_new_${tableName}`;
+}
+async function recreateTable(args, lowerer) {
+	const { tableName, contractTable, schemaColumnNames, indexes, summary, postchecks, operationClass, copyExpressions = {}, temporaryValues = {}, retypedColumns = [] } = args;
+	refuseEarlierColumnSpecs("recreateTable", tableName, contractTable.columns);
+	const tempName = rebuiltTableName(tableName);
+	const liveSet = new Set(schemaColumnNames);
+	const convertedBy = (column) => Object.hasOwn(copyExpressions, column) ? copyExpressions[column] : void 0;
+	const copiedFrom = (column) => convertedBy(column) ?? (Object.hasOwn(temporaryValues, column) ? temporaryValues[column] : void 0);
+	const sharedColumns = contractTable.columns.filter((c) => liveSet.has(c.name) || copiedFrom(c.name) !== void 0).map((c) => c.name);
+	const columnList = sharedColumns.map(quoteIdentifier).join(", ");
+	const selectList = sharedColumns.map((column) => copiedFrom(column) ?? quoteIdentifier(column)).join(", ");
+	const indexStatements = indexes.map((idx) => ({
+		description: `recreate index "${idx.name}" on "${tableName}"`,
+		sql: buildCreateIndexSql(tableName, idx.name, idx.columns)
+	}));
+	const conversions = Object.fromEntries(sharedColumns.flatMap((column) => {
+		const expression = convertedBy(column);
+		return expression === void 0 ? [] : [[column, expression]];
+	}));
+	const copyStep = sharedColumns.length > 0 ? [{
+		...step(`copy data from "${tableName}" to "${tempName}"`, `INSERT INTO ${quoteIdentifier(tempName)} (${columnList}) SELECT ${selectList} FROM ${quoteIdentifier(tableName)}`),
+		...Object.keys(conversions).length === 0 ? {} : { meta: { conversionCopy: {
+			table: tableName,
+			expressions: conversions
+		} } }
+	}] : [];
+	const defaultClauses = await renderSpecDefaults(contractTable, tableName, lowerer);
+	const clauseByColumn = new Map(contractTable.columns.map((column, index) => [column.name, defaultClauses[index] ?? ""]));
+	const tableSteps = await tableExistsSteps(lowerer, tableName);
+	const tempSteps = await tableExistsSteps(lowerer, tempName);
+	return {
+		id: `recreateTable.${tableName}`,
+		label: `Recreate table ${tableName}`,
+		summary,
+		operationClass,
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", tableName)
+		},
+		precheck: [
+			step(`ensure table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params, expectPresent(`table "${tableName}"`)),
+			step(`ensure temp table "${tempName}" does not exist`, tempSteps.absent.sql, tempSteps.absent.params, expectAbsent(`temp table "${tempName}"`)),
+			sourceColumnsCheck(tableName, schemaColumnNames)
+		],
+		execute: [
+			step(`create new table "${tempName}" with desired schema`, renderCreateTableSql(tempName, contractTable, defaultClauses)),
+			...copyStep,
+			step(`drop old table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`),
+			step(`rename "${tempName}" to "${tableName}"`, `ALTER TABLE ${quoteIdentifier(tempName)} RENAME TO ${quoteIdentifier(tableName)}`),
+			...indexStatements
+		],
+		postcheck: [
+			step(`verify table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params, expectPresent(`table "${tableName}"`)),
+			step(`verify temp table "${tempName}" is gone`, tempSteps.absent.sql, tempSteps.absent.params, expectAbsent(`temp table "${tempName}"`)),
+			rebuiltTableCheck(tableName, renderCreateTableSql(tableName, contractTable, defaultClauses)),
+			...postchecks.flatMap((check) => "sql" in check ? [markedStep(tableName, check)] : defaultPostcheck(tableName, check, clauseByColumn.get(check.columnDefault))),
+			...contractTable.columns.flatMap((column) => {
+				const by = Object.hasOwn(conversions, column.name) ? "conversion" : retypedColumns.includes(column.name) ? "cast" : void 0;
+				return by === void 0 ? [] : [{
+					...storageClassCheck(tableName, column),
+					meta: convertedColumnMeta(tableName, column.name, by)
+				}];
+			})
+		]
+	};
+}
+/**
+* Checks that the table has exactly the columns the rebuild reads, the ones it copies and the ones it
+* leaves out. The rebuild copies only the columns it knows, so on a table with another column, such
+* as one a later migration added, it would drop that column and its values.
+*/
+function sourceColumnsCheck(tableName, columns) {
+	const info = `pragma_table_info('${escapeLiteral(tableName)}')`;
+	const named = columns.length === 0 ? "" : ` AND (SELECT COUNT(*) FROM ${info} WHERE name IN (${quoteSqlList(columns)})) = ${columns.length}`;
+	return {
+		description: `ensure table "${tableName}" has exactly the columns the rebuild copies or leaves out (${columns.join(", ")})`,
+		sql: `SELECT (SELECT COUNT(*) FROM ${info}) = ${columns.length}${named}`
+	};
+}
+/**
+* Checks that the table is stored as the statement the rebuild writes. SQLite keeps a table's
+* `CREATE TABLE` text as written, and renaming the rebuilt table only replaces its name, so this holds
+* once the rebuild ran and not before, whatever text an earlier table had. It is the only check of
+* what SQLite keeps in that text alone, such as `AUTOINCREMENT`.
+*/
+function rebuiltTableCheck(tableName, statement) {
+	return {
+		description: `verify "${tableName}" is stored as the rebuilt table`,
+		sql: `SELECT (SELECT sql FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}') = '${escapeLiteral(statement)}'`
+	};
+}
+function markedStep(tableName, check) {
+	const { requiredColumn, ...step } = check;
+	const meta = { ...requiredColumn === void 0 ? {} : requiredColumnMeta(tableName, requiredColumn.column, requiredColumn.reason) };
+	return Object.keys(meta).length === 0 ? step : {
+		...step,
+		meta
+	};
+}
+/**
+* The storage classes SQLite keeps a value in once a column of `typeSql` has taken it: the column's
+* type affinity converts what it can, so a value of another class is one it could not convert.
+* See https://www.sqlite.org/datatype3.html#determination_of_column_affinity.
+*/
+function affinityStorageClasses(typeSql) {
+	const declared = typeSql.toUpperCase();
+	if (declared.includes("INT")) return ["integer"];
+	if ([
+		"CHAR",
+		"CLOB",
+		"TEXT"
+	].some((part) => declared.includes(part))) return ["text"];
+	if (declared === "" || declared.includes("BLOB")) return ["blob"];
+	if ([
+		"REAL",
+		"FLOA",
+		"DOUB"
+	].some((part) => declared.includes(part))) return ["real"];
+	return ["integer", "real"];
+}
+/**
+* The check that the copy into a rebuilt table converted every value of a retyped column to the
+* column's new type. SQLite keeps a value it cannot convert in its old storage class, so a value of
+* any other class than the column's affinity keeps fails the check.
+*/
+function storageClassCheck(tableName, column) {
+	const classes = ["null", ...affinityStorageClasses(column.typeSql)].map((storageClass) => `'${storageClass}'`).join(", ");
+	return {
+		description: `verify every value of "${column.name}" on "${tableName}" is stored as ${column.typeSql}`,
+		sql: `SELECT NOT EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE typeof(${quoteIdentifier(column.name)}) NOT IN (${classes}))`
+	};
+}
+const ConversionCopyMeta = type({ conversionCopy: {
+	table: "string",
+	expressions: "Record<string, string>"
+} });
+/**
+* The table a rebuild's copy step reads and the copy expression of each column its conversions
+* convert, when the step converts any: an error of the step may be an error of one of them.
+*/
+function conversionCopyOf(step) {
+	const meta = ConversionCopyMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.conversionCopy;
+}
+function renderSpecDefaults(spec, tableName, lowerer) {
+	return Promise.all(spec.columns.map((column) => renderSpecDefault$1(column, tableName, lowerer)));
+}
+/**
+* Checks the column's default is the text of its `DEFAULT …` clause. SQLite's
+* `pragma_table_info.dflt_value` strips the outer parentheses of an expression
+* default, so `(strftime('%Y-%m-%dT%H:%M:%fZ','now'))` is stored as `strftime('%Y-%m-%dT%H:%M:%fZ','now')`; they are
+* stripped here too.
+*/
+function defaultPostcheck(tableName, check, clause) {
+	if (clause === void 0 || !clause.startsWith("DEFAULT ")) return [];
+	const expectedRaw = stripOuterParens(clause.slice(8));
+	return [{
+		description: check.description,
+		sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(check.columnDefault)}' AND dflt_value = '${escapeLiteral(expectedRaw)}'`
+	}];
+}
+/**
+* Build a one-line summary of a recreate-table operation from the schema-diff
+* issues that triggered it. Lives next to `recreateTable` so the planner
+* (which has the issues) can produce the same description the factory
+* used to build inline. Keeping the formatting target-side keeps
+* `RecreateTableCall` issue-free at the IR layer. `SchemaDiffIssue` carries
+* no rendered message, so this renders one from each issue's path.
+*/
+function buildRecreateSummary(tableName, issues) {
+	return `Recreates table ${tableName} to apply schema changes: ${issues.map((i) => i.path.join("/")).join("; ")}`;
+}
+function nodeKindOf(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node).nodeKind;
+}
+/**
+* Returns the columns the contract expects as the table's primary key. Picks
+* up SQLite's inline `INTEGER PRIMARY KEY AUTOINCREMENT` form when no
+* explicit `primaryKey` clause is set on the spec.
+*/
+function expectedPrimaryKeyColumns(spec) {
+	if (spec.primaryKey) return spec.primaryKey.columns;
+	const inlinePk = spec.columns.find((c) => c.inlineAutoincrementPrimaryKey);
+	return inlinePk ? [inlinePk.name] : [];
+}
+/** The text `pragma_foreign_key_list` reports for a referential action; SQLite reads an absent action as `NO ACTION`. */
+function referentialActionText(action) {
+	return REFERENTIAL_ACTION_SQL[action ?? "noAction"];
+}
+function quoteSqlList(values) {
+	return values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+}
+/**
+* A condition on the index aliased `l`: it covers exactly these columns. Order is not checked, because SQLite identifies a unique index by its column set.
+*/
+function indexCoversExactly(columns) {
+	return `(SELECT COUNT(*) FROM pragma_index_info(l.name)) = ${columns.length} AND (SELECT COUNT(*) FROM pragma_index_info(l.name) WHERE name IN (${quoteSqlList(columns)})) = ${columns.length}`;
+}
+function columnNameFromNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node).name;
+}
+/**
+* A column-default issue's own node has no back-reference to its owning
+* column — it's a transient child built by `SqlColumnIR.children()`. The
+* column's id (`column:<name>`) is always the diff path's second-to-last
+* segment for a default issue (`[..., tableId, columnId, 'default']`), so
+* the name is recovered from the path rather than the node.
+*/
+function columnNameFromDefaultIssuePath(issue) {
+	const columnId = issue.path[issue.path.length - 2];
+	if (columnId === void 0) return void 0;
+	return columnId.startsWith("column:") ? columnId.slice(7) : columnId;
+}
+/**
+* Compares the declared type with `typeSql`: exactly for a data type named by its catalog text, as
+* verify compares it (ADR 273), and without case otherwise.
+*/
+function declaredTypeMatches(expected, typeSql) {
+	return expected.catalogText !== void 0 ? `type = '${escapeLiteral(typeSql)}'` : `LOWER(type) = '${escapeLiteral(typeSql.toLowerCase())}'`;
+}
+/**
+* Per-issue postchecks verifying the recreated table's shape against the
+* expected spec. Column-level issues (`sql-column` `not-equal`,
+* `sql-column-default` any reason) emit one targeted check each;
+* constraint-level issues (`sql-primary-key`, `sql-unique`, `sql-foreign-key`,
+* any reason) emit one `pragma_*`-driven check per declared constraint in the
+* expected spec, so a recreated table with the right columns but the wrong
+* PK / unique / FK shape fails the postcheck instead of passing silently.
+* Exported so the planner can pre-build the list at construction time and
+* `RecreateTableCall` doesn't have to carry `SchemaDiffIssue` objects through
+* to render time.
+*/
+function buildRecreatePostchecks(tableName, issues, spec, copiedColumns = /* @__PURE__ */ new Set(), backfilledColumns = /* @__PURE__ */ new Set()) {
+	const checks = [];
+	const t = escapeLiteral(tableName);
+	const byName = new Map(spec.columns.map((c) => [c.name, c]));
+	let hasPkIssue = false;
+	let hasUniqueIssue = false;
+	let hasFkIssue = false;
+	for (const issue of issues) {
+		const nodeKind = nodeKindOf(issue);
+		if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === "not-found") {
+			const columnName = columnNameFromNode(issue);
+			const column = columnName === void 0 ? void 0 : byName.get(columnName);
+			if (columnName === void 0 || column === void 0) continue;
+			const takesNoValue = !column.nullable && column.default === void 0 && !copiedColumns.has(columnName);
+			checks.push({
+				description: `verify "${columnName}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${escapeLiteral(columnName)}' AND "notnull" = ${column.nullable ? 0 : 1}`,
+				...backfilledColumns.has(columnName) ? { requiredColumn: {
+					column: columnName,
+					reason: "backfillMissedRows"
+				} } : takesNoValue ? { requiredColumn: {
+					column: columnName,
+					reason: "newField"
+				} } : {}
+			});
+			continue;
+		}
+		if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === "not-equal") {
+			const columnName = columnNameFromNode(issue);
+			if (columnName === void 0) continue;
+			const c = escapeLiteral(columnName);
+			const expected = blindCast(issue.expected);
+			const actual = blindCast(issue.actual);
+			if (expected.nullable !== actual.nullable) checks.push({
+				description: `verify "${columnName}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${expected.nullable ? 0 : 1}`,
+				...expected.nullable ? {} : { requiredColumn: {
+					column: columnName,
+					reason: backfilledColumns.has(columnName) ? "backfillMissedRows" : "nullValues"
+				} }
+			});
+			if (!sqlColumnTypesEqual(expected, actual)) {
+				const colSpec = byName.get(columnName);
+				if (colSpec) checks.push({
+					description: `verify "${columnName}" type on "${tableName}"`,
+					sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND ${declaredTypeMatches(expected, colSpec.typeSql)}`
+				});
+			}
+			continue;
+		}
+		if (nodeKind === RelationalSchemaNodeKind.columnDefault) {
+			const columnName = columnNameFromDefaultIssuePath(issue);
+			if (columnName === void 0) continue;
+			const c = escapeLiteral(columnName);
+			if (issueOutcome(issue) === "not-expected") {
+				checks.push({
+					description: `verify "${columnName}" has no default on "${tableName}"`,
+					sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`
+				});
+				continue;
+			}
+			if (byName.get(columnName)?.default !== void 0) checks.push({
+				description: `verify "${columnName}" default on "${tableName}"`,
+				columnDefault: columnName
+			});
+			continue;
+		}
+		if (nodeKind === RelationalSchemaNodeKind.primaryKey) hasPkIssue = true;
+		if (nodeKind === RelationalSchemaNodeKind.unique) hasUniqueIssue = true;
+		if (nodeKind === RelationalSchemaNodeKind.foreignKey) hasFkIssue = true;
+	}
+	if (hasPkIssue) {
+		const pkColumns = expectedPrimaryKeyColumns(spec);
+		const colCount = pkColumns.length;
+		if (colCount === 0) checks.push({
+			description: `verify "${tableName}" has no primary key`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = 0`
+		});
+		else checks.push({
+			description: `verify primary key on "${tableName}"`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = ${colCount} AND (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0 AND name IN (${quoteSqlList(pkColumns)})) = ${colCount}`
+		});
+	}
+	if (hasUniqueIssue) for (const u of spec.uniques ?? []) {
+		const description = u.name ? `verify unique constraint "${u.name}" on "${tableName}"` : `verify unique constraint (${u.columns.join(", ")}) on "${tableName}"`;
+		checks.push({
+			description,
+			sql: `SELECT EXISTS (SELECT 1 FROM pragma_index_list('${t}') l WHERE l."unique" = 1 AND ${indexCoversExactly(u.columns)})`
+		});
+	}
+	if (hasUniqueIssue) {
+		const expected = (spec.uniques ?? []).map((u) => `(${indexCoversExactly(u.columns)})`);
+		checks.push({
+			description: `verify "${tableName}" has no unique constraint besides the expected ones`,
+			sql: `SELECT NOT EXISTS (SELECT 1 FROM pragma_index_list('${t}') l WHERE l.origin = 'u' AND NOT (${expected.length === 0 ? "0" : expected.join(" OR ")}))`
+		});
+	}
+	if (hasFkIssue) {
+		for (const fk of spec.foreignKeys ?? []) {
+			const refTable = escapeLiteral(fk.references.table);
+			const colCount = fk.columns.length;
+			const tuples = fk.columns.map((from, i) => {
+				const to = fk.references.columns[i] ?? from;
+				return `('${escapeLiteral(from)}', '${escapeLiteral(to)}')`;
+			}).join(", ");
+			const description = `verify foreign key (${fk.columns.join(", ")}) → ${fk.references.table}(${fk.references.columns.join(", ")}) on "${tableName}"`;
+			checks.push({
+				description,
+				sql: `SELECT EXISTS (SELECT 1 FROM pragma_foreign_key_list('${t}') f WHERE f."table" = '${refTable}' AND f.on_delete = '${referentialActionText(fk.onDelete)}' AND f.on_update = '${referentialActionText(fk.onUpdate)}' GROUP BY f.id HAVING COUNT(*) = ${colCount} AND SUM(CASE WHEN (f."from", f."to") IN (${tuples}) THEN 1 ELSE 0 END) = ${colCount})`
+			});
+		}
+		const expected = spec.foreignKeys?.length ?? 0;
+		checks.push({
+			description: `verify "${tableName}" has exactly ${expected} foreign keys`,
+			sql: `SELECT (SELECT COUNT(DISTINCT id) FROM pragma_foreign_key_list('${t}')) = ${expected}`
+		});
+	}
+	return checks;
+}
+const TARGET_MIGRATION_MODULE = "@internal/sqlite/migration";
+var SqliteOpFactoryCallNode = class extends TsExpression {
+	/** The operations this call lowers to, in order: one, unless the call carries companions. */
+	toOps(lowerer) {
+		return [this.toOp(lowerer)];
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+/** Whether `call` is one of this target's calls, which lower through {@link SqliteOpFactoryCallNode.toOps}. */
+function isSqliteOpFactoryCall(call) {
+	return call instanceof SqliteOpFactoryCallNode;
+}
+function renderDdlColumnDefault(def, sql) {
+	if (!def) return "";
+	if (def.kind === "literal") return `lit(${jsonToTsSource(def.value)})`;
+	return `fn(${sql.source(def.expression.text)})`;
+}
+function renderDdlColumnAsTsCall(column, sql) {
+	const opts = [];
+	if (column.notNull) opts.push("notNull: true");
+	if (column.primaryKey) opts.push("primaryKey: true");
+	if (column.default) opts.push(`default: ${renderDdlColumnDefault(column.default, sql)}`);
+	if (column.codecRef) opts.push(`codecRef: ${jsonToTsSource(column.codecRef)}`);
+	const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+	return `col(${jsonToTsSource(column.name)}, ${jsonToTsSource(column.type)}${optsStr})`;
+}
+function renderDdlConstraintAsTsCall(constraint) {
+	switch (constraint.kind) {
+		case "primary-key": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+		case "foreign-key": {
+			const opts = [];
+			if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+			if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+			if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+			const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+			return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+		}
+		case "unique": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+		case "check-expression": throw sqliteError("CONTRACT.CONSTRAINT_INVALID", `The SQLite target does not support CHECK constraints (constraint "${constraint.name}"). The "checkConstraint" capability is Postgres-only — remove the "@@check" / "check()" declaration, or target Postgres.`, { meta: { constraintName: constraint.name } });
+	}
+}
+function constraintImportSymbols(constraints) {
+	if (!constraints || constraints.length === 0) return [];
+	const symbols = /* @__PURE__ */ new Set();
+	for (const c of constraints) if (c.kind === "primary-key") symbols.add("primaryKey");
+	else if (c.kind === "foreign-key") symbols.add("foreignKey");
+	else if (c.kind === "unique") symbols.add("unique");
+	return [...symbols];
+}
+function defaultImportSymbols(columns) {
+	const symbols = /* @__PURE__ */ new Set();
+	for (const col of columns) if (col.default?.kind === "literal") symbols.add("lit");
+	else if (col.default?.kind === "function") symbols.add("fn");
+	return [...symbols];
+}
+function columnShapesOf(columns, constraints) {
+	const primaryKey = constraints?.find((constraint) => constraint.kind === "primary-key");
+	return columns.map((column) => {
+		if (column.type.endsWith(" PRIMARY KEY AUTOINCREMENT")) return {
+			name: column.name,
+			typeSql: column.type.slice(0, -26),
+			notNull: false,
+			primaryKeyPosition: 1
+		};
+		return {
+			name: column.name,
+			typeSql: column.type,
+			notNull: column.notNull === true,
+			primaryKeyPosition: column.primaryKey ? 1 : (primaryKey?.columns.indexOf(column.name) ?? -1) + 1
+		};
+	});
+}
+var CreateTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "createTable";
+	operationClass = "additive";
+	tableName;
+	columns;
+	constraints;
+	label;
+	constructor(tableName, columns, constraints) {
+		super();
+		this.tableName = tableName;
+		this.columns = Object.freeze([...columns]);
+		this.constraints = constraints ? Object.freeze([...constraints]) : void 0;
+		this.label = `Create table ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `CreateTableCall.toOp: a DDL lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		const ddlNode = createTable({
+			table: this.tableName,
+			columns: this.columns,
+			...ifDefined("constraints", this.constraints)
+		});
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+		const tableName = this.tableName;
+		const tableChecks = tableExistsAst(tableName);
+		const absent = await lowerer.lowerToExecuteRequest(tableChecks.tableAbsent());
+		const present = await lowerer.lowerToExecuteRequest(tableChecks.tablePresent());
+		return {
+			id: `table.${tableName}`,
+			label: `Create table ${tableName}`,
+			summary: `Creates table ${tableName} with required columns`,
+			operationClass: "additive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("table", tableName)
+			},
+			precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params, expectAbsent(`table "${tableName}"`))],
+			execute: [{
+				description: `create table "${tableName}"`,
+				sql: statement.sql,
+				params: statement.params ?? []
+			}],
+			postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params, expectPresent(`table "${tableName}"`)), tableColumnsCheck(tableName, columnShapesOf(this.columns, this.constraints))]
+		};
+	}
+	renderTypeScript() {
+		return this.#written().source;
+	}
+	#written() {
+		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
+		const columnsList = this.columns.map((column) => renderDdlColumnAsTsCall(column, sql)).join(", ");
+		const constraintsList = this.constraints ? this.constraints.map(renderDdlConstraintAsTsCall).join(", ") : void 0;
+		const opts = [];
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`columns: [${columnsList}]`);
+		if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+		return {
+			source: `this.createTable({ ${opts.join(", ")} })`,
+			imports: sql.imports()
+		};
+	}
+	importRequirements() {
+		const req = [];
+		if (this.columns.length > 0) {
+			req.push({
+				moduleSpecifier: TARGET_MIGRATION_MODULE,
+				symbol: "col"
+			});
+			for (const sym of defaultImportSymbols(this.columns)) req.push({
+				moduleSpecifier: TARGET_MIGRATION_MODULE,
+				symbol: sym
+			});
+		}
+		for (const sym of constraintImportSymbols(this.constraints)) req.push({
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: sym
+		});
+		req.push(...this.#written().imports);
+		return req;
+	}
+};
+var DropTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	tableName;
+	label;
+	constructor(tableName) {
+		super();
+		this.tableName = tableName;
+		this.label = `Drop table ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		const checks = tableExistsAst(this.tableName);
+		const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+		return {
+			id: `dropTable.${this.tableName}`,
+			label: `Drop table ${this.tableName}`,
+			summary: `Drops table ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("table", this.tableName)
+			},
+			precheck: [step(`ensure table "${this.tableName}" exists`, present.sql, present.params, expectPresent(`table "${this.tableName}"`))],
+			execute: [step(`drop table "${this.tableName}"`, `DROP TABLE ${quoteIdentifier(this.tableName)}`)],
+			postcheck: [step(`verify table "${this.tableName}" is gone`, absent.sql, absent.params, expectAbsent(`table "${this.tableName}"`))]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropTable({ table: ${jsonToTsSource(this.tableName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/** The replaced indexes' drops, then their creates, since a create may take a dropped name. */
+function indexReplacementCalls(replacements) {
+	return [...replacements.map(({ drop }) => drop), ...replacements.map(({ create }) => create)];
+}
+var RenameTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "renameTable";
+	operationClass = "widening";
+	oldTableName;
+	/** The new name: the table's contract-side identity after the rename. */
+	tableName;
+	label;
+	/** The indexes named after the old table, which SQLite cannot rename, so it replaces them. */
+	indexReplacements;
+	/**
+	* The replacements' drops, then their creates. They run after the table rename and are never
+	* rendered on their own.
+	*/
+	companions;
+	constructor(oldTableName, tableName, indexReplacements) {
+		super();
+		this.oldTableName = oldTableName;
+		this.tableName = tableName;
+		this.label = `Rename table ${oldTableName} to ${tableName}`;
+		this.indexReplacements = Object.freeze([...indexReplacements]);
+		this.companions = Object.freeze(indexReplacementCalls(indexReplacements));
+		this.freeze();
+	}
+	/** The id of the operation this call lowers to. */
+	get operationId() {
+		return `renameTable.${this.oldTableName}`;
+	}
+	toOps(lowerer) {
+		return [this.toOp(lowerer), ...this.companions.map((companion) => companion.toOp(lowerer))];
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `RenameTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.oldTableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.oldTableName
+		} });
+		const fromChecks = tableExistsAst(this.oldTableName);
+		const toChecks = tableExistsAst(this.tableName);
+		const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.tablePresent());
+		const onlyCase = renameChangesOnlyCase(this.oldTableName, this.tableName);
+		const toAbsent = await lowerer.lowerToExecuteRequest(onlyCase ? toChecks.tableAbsent() : tableNameTakenAst(this.tableName).nameFree());
+		const viaName = renameTableViaName(this.tableName);
+		const viaAbsent = onlyCase ? await lowerer.lowerToExecuteRequest(tableExistsAst(viaName).tableAbsent()) : void 0;
+		const toPresent = await lowerer.lowerToExecuteRequest(toChecks.tablePresent());
+		const fromAbsent = await lowerer.lowerToExecuteRequest(fromChecks.tableAbsent());
+		return {
+			id: this.operationId,
+			label: this.label,
+			summary: `Renames table ${this.oldTableName} to ${this.tableName}, keeping its rows`,
+			operationClass: "widening",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("table", this.tableName)
+			},
+			precheck: [
+				step(`ensure table "${this.oldTableName}" exists`, fromPresent.sql, fromPresent.params, expectPresent(`table "${this.oldTableName}"`)),
+				step(onlyCase ? `ensure table "${this.tableName}" does not exist` : `ensure no table or index is named "${this.tableName}" in any case`, toAbsent.sql, toAbsent.params, expectAbsent(onlyCase ? `table "${this.tableName}"` : `a table or index named "${this.tableName}" in any case`)),
+				...viaAbsent === void 0 ? [] : [step(`ensure table "${viaName}" does not exist (a rename that only changes case passes through this temporary name, because SQLite compares table names without case)`, viaAbsent.sql, viaAbsent.params, expectAbsent(`table "${viaName}"`))]
+			],
+			execute: renameTableSteps(this.oldTableName, this.tableName),
+			postcheck: [step(`verify table "${this.tableName}" exists`, toPresent.sql, toPresent.params, expectPresent(`table "${this.tableName}"`)), step(`verify table "${this.oldTableName}" no longer exists`, fromAbsent.sql, fromAbsent.params, expectAbsent(`table "${this.oldTableName}"`))]
+		};
+	}
+	renderTypeScript() {
+		return `...this.renameTable({ table: ${jsonToTsSource(this.oldTableName)}, to: ${jsonToTsSource(this.tableName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var RenameColumnCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "renameColumn";
+	operationClass = "widening";
+	tableName;
+	oldColumnName;
+	/** The new name: the column's contract-side identity after the rename. */
+	columnName;
+	label;
+	/** The indexes on the column whose wire names change, which SQLite cannot rename. */
+	indexReplacements;
+	/**
+	* The replacements' drops, then their creates. They run after the column rename and are never
+	* rendered on their own.
+	*/
+	companions;
+	constructor(tableName, oldColumnName, columnName, indexReplacements) {
+		super();
+		this.tableName = tableName;
+		this.oldColumnName = oldColumnName;
+		this.columnName = columnName;
+		this.label = `Rename column ${oldColumnName} on ${tableName} to ${columnName}`;
+		this.indexReplacements = Object.freeze([...indexReplacements]);
+		this.companions = Object.freeze(indexReplacementCalls(indexReplacements));
+		this.freeze();
+	}
+	toOps(lowerer) {
+		return [this.toOp(lowerer), ...this.companions.map((companion) => companion.toOp(lowerer))];
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `RenameColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.oldColumnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		return renameColumn(this.tableName, this.oldColumnName, this.columnName, lowerer);
+	}
+	renderTypeScript() {
+		return `...this.renameColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.oldColumnName)}, to: ${jsonToTsSource(this.columnName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+function refuseUnsafeCopyExpressions(tableName, option, expressions) {
+	for (const [column, expression] of Object.entries(expressions)) {
+		if (expression.kind !== "sql") continue;
+		const refused = checkSqlExpressionText(expression.sql, SQLITE_QUOTING);
+		if (refused === void 0) continue;
+		const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+		throw sqliteError("MIGRATION.SQL_EXPRESSION_INVALID", `${call}: ${option}.${column} ${JSON.stringify(expression.sql)} holds ${refused}, which could end or extend the INSERT … SELECT statement it is written into`, {
+			why: "A copy expression or a temporary value is written into the SELECT that copies the rows into the rebuilt table. The check refuses a semicolon, a SQL comment, dollar quoting, and a comma or a statement keyword outside parentheses, since each could end or extend that statement; it does not check that the text is valid SQL.",
+			fix: `Write ${option}.${column} as one SQL expression over the old table's columns, such as CAST("${column}" AS INTEGER). If it holds a comma or a keyword such as FROM outside parentheses, wrap it in parentheses.`,
+			meta: {
+				call,
+				field: `${option}.${column}`,
+				expression: expression.sql,
+				refused
+			}
+		});
+	}
+}
+function refuseUnknownCopyExpressionColumns(tableName, contractTable, named) {
+	const columns = contractTable.columns.map((column) => column.name);
+	const unknown = [
+		...Object.keys(named.copyExpressions).map((key) => ({
+			option: `copyExpressions.${key}`,
+			key
+		})),
+		...Object.keys(named.temporaryValues).map((key) => ({
+			option: `temporaryValues.${key}`,
+			key
+		})),
+		...named.retypedColumns.map((key) => ({
+			option: `retypedColumns entry ${JSON.stringify(key)}`,
+			key
+		}))
+	].find(({ key }) => !columns.includes(key));
+	if (unknown === void 0) return;
+	const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+	throw sqliteError("MIGRATION.COPY_EXPRESSION_COLUMN_UNKNOWN", `${call}: ${unknown.option} names no column of the new table. Its columns are ${columns.map((column) => JSON.stringify(column)).join(", ")}.`, {
+		why: "Each key of copyExpressions and temporaryValues, and each entry of retypedColumns, names a column of the new table. One that names no column applies to nothing, so the column meant would be copied unchanged or left without a value, or its values would go unchecked.",
+		fix: "Name a column in contractTable.columns, with the same letters and case.",
+		meta: {
+			call,
+			key: unknown.key,
+			columns
+		}
+	});
+}
+/**
+* A temporary value fills a column the old table does not have, and only that: for a column the
+* old table has it would replace every existing value, and a column with a copy expression is
+* already filled by its conversion.
+*/
+function refuseMisplacedTemporaryValues(tableName, schemaColumnNames, copyExpressions, temporaryValues) {
+	const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+	for (const column of Object.keys(temporaryValues)) {
+		if (schemaColumnNames.includes(column)) throw sqliteError("MIGRATION.TEMPORARY_VALUE_INVALID", `${call}: temporaryValues.${column} names a column the old table already has, so the copy would replace every value of it.`, {
+			why: "A temporary value fills a new column in the existing rows. A column the old table has keeps its values through the copy, or is converted by a copy expression.",
+			fix: `Remove temporaryValues.${column}. To change the values of "${column}", write a conversion in copyExpressions.${column} instead.`,
+			meta: {
+				call,
+				column,
+				reason: "existingColumn"
+			}
+		});
+		if (Object.hasOwn(copyExpressions, column)) throw sqliteError("MIGRATION.TEMPORARY_VALUE_INVALID", `${call}: "${column}" is named in both copyExpressions and temporaryValues, so it would be filled twice.`, {
+			why: "A column is filled either by the conversion in copyExpressions or by a temporary value, not both.",
+			fix: `Keep one of copyExpressions.${column} and temporaryValues.${column}.`,
+			meta: {
+				call,
+				column,
+				reason: "alsoConverted"
+			}
+		});
+	}
+}
+function sqlOfSlots(slots) {
+	return Object.fromEntries(Object.entries(slots).flatMap(([column, slot]) => {
+		const sql = sqlOfSlot(slot);
+		return sql === void 0 ? [] : [[column, sql]];
+	}));
+}
+var RecreateTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "recreateTable";
+	operationClass;
+	tableName;
+	contractTable;
+	schemaColumnNames;
+	indexes;
+	summary;
+	postchecks;
+	label;
+	/** The conversion each named column of the new table is copied through, in place of the live column. */
+	copyExpressions;
+	/** The value each named new column takes in the existing rows. */
+	temporaryValues;
+	/** The columns whose type changes; the rebuild checks each after its copy, as a conversion when it has a copy expression and as SQLite's cast otherwise. */
+	retypedColumns;
+	constructor(args) {
+		super();
+		refuseUnsafeCopyExpressions(args.tableName, "copyExpressions", args.copyExpressions ?? {});
+		refuseUnsafeCopyExpressions(args.tableName, "temporaryValues", args.temporaryValues ?? {});
+		refuseUnknownCopyExpressionColumns(args.tableName, args.contractTable, {
+			copyExpressions: args.copyExpressions ?? {},
+			temporaryValues: args.temporaryValues ?? {},
+			retypedColumns: args.retypedColumns ?? []
+		});
+		refuseMisplacedTemporaryValues(args.tableName, args.schemaColumnNames, args.copyExpressions ?? {}, args.temporaryValues ?? {});
+		this.copyExpressions = Object.freeze({ ...args.copyExpressions });
+		this.temporaryValues = Object.freeze({ ...args.temporaryValues });
+		this.retypedColumns = Object.freeze([...args.retypedColumns ?? []]);
+		this.tableName = args.tableName;
+		this.contractTable = args.contractTable;
+		this.schemaColumnNames = args.schemaColumnNames;
+		this.indexes = args.indexes;
+		this.summary = args.summary;
+		this.postchecks = args.postchecks;
+		this.operationClass = args.operationClass;
+		this.label = `Recreate table ${args.tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `RecreateTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		const copies = Object.entries(this.copyExpressions);
+		if (copies.some(([, expression]) => isUnfilledSlot(expression))) return unfilledPlaceholderOperation(this.label);
+		return recreateTable({
+			tableName: this.tableName,
+			contractTable: this.contractTable,
+			schemaColumnNames: this.schemaColumnNames,
+			indexes: this.indexes,
+			summary: this.summary,
+			postchecks: this.postchecks,
+			operationClass: this.operationClass,
+			retypedColumns: this.retypedColumns,
+			...copies.length === 0 ? {} : { copyExpressions: sqlOfSlots(this.copyExpressions) },
+			...Object.keys(this.temporaryValues).length === 0 ? {} : { temporaryValues: sqlOfSlots(this.temporaryValues) }
+		}, lowerer);
+	}
+	#slotsSource(slots, sql) {
+		return `{ ${Object.entries(slots).map(([column, expression]) => `${jsonToTsSource(column)}: ${slotSource(expression, sql)}`).join(", ")} }`;
+	}
+	renderTypeScript() {
+		return this.#written().source;
+	}
+	importRequirements() {
+		return [...Object.values(this.copyExpressions).some(isUnfilledSlot) ? [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}] : [], ...this.#written().imports];
+	}
+	#written() {
+		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
+		return {
+			source: `this.recreateTable(${tsObjectSource([
+				["tableName", jsonToTsSource(this.tableName)],
+				["contractTable", renderTableSpec(this.contractTable, sql)],
+				["schemaColumnNames", jsonToTsSource(this.schemaColumnNames)],
+				["indexes", jsonToTsSource(this.indexes)],
+				["summary", jsonToTsSource(this.summary)],
+				["postchecks", tsArraySource(this.postchecks.map(renderPostcheck))],
+				["operationClass", jsonToTsSource(this.operationClass)],
+				...Object.keys(this.copyExpressions).length === 0 ? [] : [["copyExpressions", this.#slotsSource(this.copyExpressions, sql)]],
+				...Object.keys(this.temporaryValues).length === 0 ? [] : [["temporaryValues", this.#slotsSource(this.temporaryValues, sql)]],
+				...this.retypedColumns.length === 0 ? [] : [["retypedColumns", jsonToTsSource(this.retypedColumns)]]
+			])})`,
+			imports: sql.imports()
+		};
+	}
+};
+var AddColumnCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "addColumn";
+	operationClass = "additive";
+	tableName;
+	columnName;
+	column;
+	label;
+	constructor(tableName, column) {
+		super();
+		this.tableName = tableName;
+		this.columnName = column.name;
+		this.column = column;
+		this.label = `Add column ${column.name} on ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `AddColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			columnName: this.column.name
+		} });
+		return addColumn(this.tableName, this.column, lowerer);
+	}
+	renderTypeScript() {
+		return this.#written().source;
+	}
+	importRequirements() {
+		return this.#written().imports;
+	}
+	#written() {
+		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
+		return {
+			source: `this.addColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${renderColumnSpec(this.column, sql)} })`,
+			imports: sql.imports()
+		};
+	}
+};
+var DropColumnCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropColumn";
+	operationClass = "destructive";
+	tableName;
+	columnName;
+	label;
+	constructor(tableName, columnName) {
+		super();
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop column ${columnName} on ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			columnName: this.columnName
+		} });
+		const checks = columnExistsAst(this.tableName, this.columnName);
+		const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+		return {
+			id: `dropColumn.${this.tableName}.${this.columnName}`,
+			label: `Drop column ${this.columnName} on ${this.tableName}`,
+			summary: `Drops column ${this.columnName} on ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("column", this.columnName, this.tableName)
+			},
+			precheck: [step(`ensure column "${this.columnName}" exists on "${this.tableName}"`, present.sql, present.params, expectPresent(`column "${this.columnName}" on "${this.tableName}"`))],
+			execute: [step(`drop column "${this.columnName}" from "${this.tableName}"`, dropColumnExecuteSql(this.tableName, this.columnName))],
+			postcheck: [step(`verify column "${this.columnName}" is gone from "${this.tableName}"`, absent.sql, absent.params, expectAbsent(`column "${this.columnName}" on "${this.tableName}"`))]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.columnName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var CreateIndexCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "createIndex";
+	operationClass = "additive";
+	tableName;
+	indexName;
+	columns;
+	label;
+	constructor(tableName, indexName, columns) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.columns = columns;
+		this.label = `Create index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	/** The id of the operation this call lowers to. */
+	get operationId() {
+		return `index.${this.tableName}.${this.indexName}`;
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `CreateIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			indexName: this.indexName
+		} });
+		const checks = indexExistsAst(this.indexName);
+		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+		return {
+			id: this.operationId,
+			label: `Create index ${this.indexName} on ${this.tableName}`,
+			summary: `Creates index ${this.indexName} on ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [step(`ensure index "${this.indexName}" is missing`, absent.sql, absent.params, expectAbsent(`index "${this.indexName}"`))],
+			execute: [step(`create index "${this.indexName}"`, buildCreateIndexSql(this.tableName, this.indexName, this.columns))],
+			postcheck: [step(`verify index "${this.indexName}" exists`, present.sql, present.params, expectPresent(`index "${this.indexName}"`)), indexDefinitionCheck(this.tableName, this.indexName, this.columns, false)]
+		};
+	}
+	renderTypeScript() {
+		return `this.createIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+var DropIndexCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropIndex";
+	operationClass = "widening";
+	tableName;
+	indexName;
+	label;
+	constructor(tableName, indexName) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.label = `Drop index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	/** The id of the operation this call lowers to. */
+	get operationId() {
+		return `dropIndex.${this.tableName}.${this.indexName}`;
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			indexName: this.indexName
+		} });
+		const checks = indexExistsAst(this.indexName);
+		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+		return {
+			id: this.operationId,
+			label: `Drop index ${this.indexName} on ${this.tableName}`,
+			summary: `Drops index ${this.indexName} on ${this.tableName} which is not in the contract`,
+			operationClass: "widening",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [step(`ensure index "${this.indexName}" exists`, present.sql, present.params, expectPresent(`index "${this.indexName}"`))],
+			execute: [step(`drop index "${this.indexName}"`, buildDropIndexSql(this.indexName))],
+			postcheck: [step(`verify index "${this.indexName}" is gone`, absent.sql, absent.params, expectAbsent(`index "${this.indexName}"`))]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* A planner-generated data-transform stub. The current default strategy
+* (`nullabilityTighteningBackfillStrategy`) emits one of these with a
+* backfill-flavored `id`/`label` when the policy allows `'data'` and the
+* contract tightens a column's nullability, but the op itself is generic —
+* any future strategy that needs a placeholder data step can construct one
+* with its own id/label.
+*
+* `toOp()` always rejects with `MIGRATION.UNFILLED_PLACEHOLDER`: the planner cannot lower a stubbed
+* transform to a runtime op — the user must edit the rendered
+* `migration.ts` and re-emit.
+*/
+var DataTransformCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dataTransform";
+	operationClass = "data";
+	id;
+	label;
+	tableName;
+	columnName;
+	/** The slot the user fills with the statement that fills the column: `<Model.field>:run`. */
+	slot;
+	constructor(id, label, tableName, columnName, slot) {
+		super();
+		this.id = id;
+		this.label = label;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.slot = slot;
+		this.freeze();
+	}
+	toOp(_lowerer) {
+		return unfilledPlaceholderOperation(this.label);
+	}
+	renderTypeScript() {
+		const slot = this.slot;
+		return [
+			"dataTransform({",
+			`  id: ${jsonToTsSource(this.id)},`,
+			`  label: ${jsonToTsSource(this.label)},`,
+			`  table: ${jsonToTsSource(this.tableName)},`,
+			`  description: ${jsonToTsSource(`Backfill NULL ${this.columnName} values in ${this.tableName}`)},`,
+			`  run: () => placeholder(${jsonToTsSource(slot)}),`,
+			"})"
+		].join("\n");
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}, {
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}];
+	}
+};
+/**
+* Laundered pre-built operation. Mirrors Postgres's `RawSqlCall`: wraps an
+* already-materialized `SqlMigrationPlanOperation` (typically produced by a
+* SQL-family helper or a codec lifecycle hook) so the planner can carry it
+* alongside structured call IR. `toOp()` returns the stored op unchanged;
+* `renderTypeScript()` emits `rawSql({...})` with the op serialized as a
+* JSON literal — round-tripping requires every field on the op to be
+* JSON-serializable (no closures).
+*/
+var RawSqlCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass;
+	label;
+	op;
+	constructor(op) {
+		super();
+		this.op = op;
+		this.label = op.label;
+		this.operationClass = op.operationClass;
+		this.freeze();
+	}
+	toOp(_lowerer) {
+		return this.op;
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource(this.op)})`;
+	}
+};
+function definedSourceEntries(sources) {
+	return Object.entries(sources).flatMap(([key, source]) => source === void 0 ? [] : [[key, source]]);
+}
+function renderIfDefined(value) {
+	return value === void 0 ? void 0 : jsonToTsSource(value);
+}
+function renderColumnSpec(column, sql) {
+	return tsObjectSource(definedSourceEntries({
+		name: jsonToTsSource(column.name),
+		typeSql: jsonToTsSource(column.typeSql),
+		default: column.default === void 0 ? void 0 : renderSpecDefault(column.default, sql),
+		codecRef: renderIfDefined(column.codecRef),
+		nullable: jsonToTsSource(column.nullable),
+		inlineAutoincrementPrimaryKey: renderIfDefined(column.inlineAutoincrementPrimaryKey)
+	}));
+}
+function renderTableSpec(table, sql) {
+	return tsObjectSource(definedSourceEntries({
+		columns: tsArraySource(table.columns.map((column) => renderColumnSpec(column, sql))),
+		primaryKey: renderIfDefined(table.primaryKey),
+		uniques: renderIfDefined(table.uniques),
+		foreignKeys: renderIfDefined(table.foreignKeys)
+	}));
+}
+function renderSpecDefault(columnDefault, sql) {
+	if (columnDefault.kind === "literal") return jsonToTsSource(columnDefault);
+	return tsObjectSource(definedSourceEntries({
+		kind: jsonToTsSource(columnDefault.kind),
+		expression: sql.source(columnDefault.expression)
+	}));
+}
+function renderPostcheck(postcheck) {
+	if ("sql" in postcheck) return tsObjectSource(definedSourceEntries({
+		description: jsonToTsSource(postcheck.description),
+		sql: tsQuotedTextSource(postcheck.sql),
+		requiredColumn: postcheck.requiredColumn === void 0 ? void 0 : jsonToTsSource(postcheck.requiredColumn)
+	}));
+	return tsObjectSource(definedSourceEntries({
+		description: jsonToTsSource(postcheck.description),
+		columnDefault: jsonToTsSource(postcheck.columnDefault)
+	}));
+}
+//#endregion
+export { step as C, sqliteIdentifiersCollide as S, indexReplacementCalls as _, DropColumnCall as a, renameTableSteps as b, INLINE_AUTOINCREMENT_PRIMARY_KEY as c, RenameColumnCall as d, RenameTableCall as f, conversionCopyOf as g, buildRecreateSummary as h, DataTransformCall as i, RawSqlCall as l, buildRecreatePostchecks as m, CreateIndexCall as n, DropIndexCall as o, affinityStorageClasses as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RecreateTableCall as u, isSqliteOpFactoryCall as v, sqliteDefaultToDdlColumnDefault as x, rebuiltTableName as y };
+
+//# sourceMappingURL=op-factory-call-emj9Xp05-BFLkxrAK.mjs.map