@prisma/orm-target-sqlite 8.0.0-rc.16-dev.6 → 8.0.0-rc.16-dev.8

package/dist/{render-ops-KxAmAz6d-W2xyvA5y.mjs → render-ops-BfFXRHIV-x1i1WAHz.mjs}

@@ -1,7 +1,8 @@
 import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
+import { g as isSqliteOpFactoryCall } from "./op-factory-call-Cwsf4slr-DRGuq5SV.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { isThenable } from "@prisma/orm-framework/utils/promise";
-//#region ../../../3-targets/3-targets/sqlite/dist/render-ops-KxAmAz6d.mjs
+//#region ../../../3-targets/3-targets/sqlite/dist/render-ops-BfFXRHIV.mjs
 function assertSqliteOp(op, callFactoryName) {
 	const targetId = blindCast(op).target?.id;
 	if (targetId !== "sqlite") throw sqliteError("MIGRATION.TARGET_MISMATCH", `renderOps: expected sqlite op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the sqlite planner path; check the call's target binding.`, { meta: {
@@ -10,18 +11,24 @@ function assertSqliteOp(op, callFactoryName) {
 		factoryName: callFactoryName
 	} });
 }
-function renderOps(calls, lowerer) {
-	return calls.map((c) => {
-		const opOrPromise = blindCast(c).toOp(lowerer);
-		if (isThenable(opOrPromise)) return opOrPromise.then((op) => {
-			assertSqliteOp(op, c.factoryName);
+function checkedOp(opOrPromise, callFactoryName) {
+	if (isThenable(opOrPromise)) {
+		const checked = opOrPromise.then((op) => {
+			assertSqliteOp(op, callFactoryName);
 			return op;
 		});
-		assertSqliteOp(opOrPromise, c.factoryName);
-		return opOrPromise;
+		checked.catch(() => void 0);
+		return checked;
+	}
+	assertSqliteOp(opOrPromise, callFactoryName);
+	return opOrPromise;
+}
+function renderOps(calls, lowerer) {
+	return calls.flatMap((c) => {
+		return (isSqliteOpFactoryCall(c) ? c.toOps(lowerer) : [blindCast(c).toOp(lowerer)]).map((opOrPromise) => checkedOp(opOrPromise, c.factoryName));
 	});
 }
 //#endregion
 export { renderOps as t };
 
-//# sourceMappingURL=render-ops-KxAmAz6d-W2xyvA5y.mjs.map
+//# sourceMappingURL=render-ops-BfFXRHIV-x1i1WAHz.mjs.map

package/dist/render-ops-BfFXRHIV-x1i1WAHz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-BfFXRHIV-x1i1WAHz.mjs","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/render-ops-BfFXRHIV.mjs"],"sourcesContent":["import { n as sqliteError } from \"./errors-DnR-sMHS.mjs\";\nimport { p as isSqliteOpFactoryCall } from \"./op-factory-call-Cwsf4slr.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { isThenable } from \"@internal/utils/promise\";\n//#region src/core/migrations/render-ops.ts\nfunction assertSqliteOp(op, callFactoryName) {\n\tconst targetId = blindCast(op).target?.id;\n\tif (targetId !== \"sqlite\") throw sqliteError(\"MIGRATION.TARGET_MISMATCH\", `renderOps: expected sqlite op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the sqlite planner path; check the call's target binding.`, { meta: {\n\t\topId: op.id,\n\t\ttargetId: String(targetId),\n\t\tfactoryName: callFactoryName\n\t} });\n}\nfunction checkedOp(opOrPromise, callFactoryName) {\n\tif (isThenable(opOrPromise)) {\n\t\tconst checked = opOrPromise.then((op) => {\n\t\t\tassertSqliteOp(op, callFactoryName);\n\t\t\treturn op;\n\t\t});\n\t\tchecked.catch(() => void 0);\n\t\treturn checked;\n\t}\n\tassertSqliteOp(opOrPromise, callFactoryName);\n\treturn opOrPromise;\n}\nfunction renderOps(calls, lowerer) {\n\treturn calls.flatMap((c) => {\n\t\treturn (isSqliteOpFactoryCall(c) ? c.toOps(lowerer) : [blindCast(c).toOp(lowerer)]).map((opOrPromise) => checkedOp(opOrPromise, c.factoryName));\n\t});\n}\n//#endregion\nexport { renderOps as t };\n\n//# sourceMappingURL=render-ops-BfFXRHIV.mjs.map"],"mappings":";;;;;AAKA,SAAS,eAAe,IAAI,iBAAiB;CAC5C,MAAM,WAAW,UAAU,EAAE,CAAC,CAAC,QAAQ;CACvC,IAAI,aAAa,UAAU,MAAM,YAAY,6BAA6B,oDAAoD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,0HAA0H,EAAE,MAAM;EACvU,MAAM,GAAG;EACT,UAAU,OAAO,QAAQ;EACzB,aAAa;CACd,EAAE,CAAC;AACJ;AACA,SAAS,UAAU,aAAa,iBAAiB;CAChD,IAAI,WAAW,WAAW,GAAG;EAC5B,MAAM,UAAU,YAAY,MAAM,OAAO;GACxC,eAAe,IAAI,eAAe;GAClC,OAAO;EACR,CAAC;EACD,QAAQ,YAAY,KAAK,CAAC;EAC1B,OAAO;CACR;CACA,eAAe,aAAa,eAAe;CAC3C,OAAO;AACR;AACA,SAAS,UAAU,OAAO,SAAS;CAClC,OAAO,MAAM,SAAS,MAAM;EAC3B,QAAQ,sBAAsB,CAAC,IAAI,EAAE,MAAM,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,EAAA,CAAG,KAAK,gBAAgB,UAAU,aAAa,EAAE,WAAW,CAAC;CAC/I,CAAC;AACF"}

package/dist/{sqlite-contract-view-BYR10usg-BteDAUZr.mjs → sqlite-contract-view-BrXalcTm-DYDH4LQC.mjs}

@@ -1,11 +1,12 @@
 import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
+import { n as quoteIdentifier } from "./sql-utils-C2O4zVkP-Dz3Hb85I.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
 import { SqlNamespaceBase } from "@prisma/orm-family-sql/contract/types";
 import { buildSqlSingleNamespaceView } from "@prisma/orm-family-sql/contract/contract-view";
 import { SqlContractSerializerBase } from "@prisma/orm-family-sql/family/ir";
 import { tableEntityKind } from "@prisma/orm-family-sql/contract/entity-kinds";
-//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-contract-view-BYR10usg.mjs
+//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-contract-view-BrXalcTm.mjs
 const SQLITE_NAMESPACE_KIND = "sqlite-namespace";
 /**
 * SQLite namespace concretion carrying table metadata under
@@ -35,7 +36,7 @@ var SqliteDatabase = class extends SqlNamespaceBase {
 		return "";
 	}
 	qualifyTable(tableName) {
-		return `"${tableName}"`;
+		return quoteIdentifier(tableName);
 	}
 };
 /**
@@ -148,4 +149,4 @@ const SqliteContractView = {
 //#endregion
 export { sqliteCreateNamespace as i, SqliteContractView as n, SqliteUnboundDatabase as r, SqliteContractSerializer as t };
 
-//# sourceMappingURL=sqlite-contract-view-BYR10usg-BteDAUZr.mjs.map
+//# sourceMappingURL=sqlite-contract-view-BrXalcTm-DYDH4LQC.mjs.map

package/dist/sqlite-contract-view-BrXalcTm-DYDH4LQC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-contract-view-BrXalcTm-DYDH4LQC.mjs","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/sqlite-contract-view-BrXalcTm.mjs"],"sourcesContent":["import { n as sqliteError } from \"./errors-DnR-sMHS.mjs\";\nimport { n as quoteIdentifier } from \"./sql-utils-C2O4zVkP.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { SqlNamespaceBase } from \"@internal/sql-contract/types\";\nimport { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from \"@internal/framework-components/ir\";\nimport { buildSqlSingleNamespaceView } from \"@internal/sql-contract/contract-view\";\nimport { SqlContractSerializerBase } from \"@internal/family-sql/ir\";\nimport { tableEntityKind } from \"@internal/sql-contract/entity-kinds\";\n//#region src/core/sqlite-unbound-database.ts\nconst SQLITE_NAMESPACE_KIND = \"sqlite-namespace\";\n/**\n* SQLite namespace concretion carrying table metadata under\n* `entries.table` and unqualified `qualifyTable()` emission for runtime\n* SQL rendering.\n*/\nvar SqliteDatabase = class extends SqlNamespaceBase {\n\tid;\n\tentries;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.id = input.id;\n\t\tconst dispatched = hydrateNamespaceEntities(input.entries, /* @__PURE__ */ new Map([[\"table\", tableEntityKind]]), \"carry\");\n\t\tthis.entries = Object.freeze(blindCast(dispatched));\n\t\tObject.defineProperty(this, \"kind\", {\n\t\t\tvalue: SQLITE_NAMESPACE_KIND,\n\t\t\twritable: false,\n\t\t\tenumerable: false,\n\t\t\tconfigurable: true\n\t\t});\n\t\tfreezeNode(this);\n\t}\n\tget table() {\n\t\treturn this.entries.table ?? Object.freeze({});\n\t}\n\tqualifier() {\n\t\treturn \"\";\n\t}\n\tqualifyTable(tableName) {\n\t\treturn quoteIdentifier(tableName);\n\t}\n};\n/**\n* SQLite target `Namespace` concretion. SQLite has no schema or\n* database-namespacing concept at the SQL level — there is exactly one\n* effective namespace per connection, so the target ships a single\n* singleton bound to the framework's `UNBOUND_NAMESPACE_ID` slot.\n*\n* Qualifier emission elides the prefix entirely: rendered DDL and\n* queries look unqualified (`CREATE TABLE \"users\" (...)`), matching\n* SQLite's native dialect. Call sites stay polymorphic — they ask the\n* namespace for its qualifier and consume the empty/unqualified result\n* the same way Postgres consumes a `\"schema\"` prefix.\n*\n* The SQLite PSL interpreter rejects every explicit `namespace { … }`\n* block with a diagnostic naming SQLite; only the implicit\n* `__unspecified__` AST bucket reaches the SQLite interpreter, which\n* lowers it to this singleton.\n*/\nvar SqliteUnboundDatabase = class SqliteUnboundDatabase extends SqliteDatabase {\n\tstatic instance = new SqliteUnboundDatabase();\n\tconstructor() {\n\t\tsuper({\n\t\t\tid: UNBOUND_NAMESPACE_ID,\n\t\t\tentries: { table: {} }\n\t\t});\n\t}\n};\n/**\n* The SQLite target's rejection of expression and partial indexes: the\n* family-shared authoring surfaces parse `expression:`/`where:` for every\n* SQL target, but SQLite neither renders nor introspects them (project\n* non-goal) — a contract carrying one must fail loudly at lowering instead\n* of silently producing an unverifiable index. Target-owned so no family\n* code branches on the target.\n*/\nfunction rejectSqlBodyIndexes(input) {\n\tconst tables = input.entries[\"table\"];\n\tif (tables === void 0) return;\n\tfor (const [tableName, table] of Object.entries(tables)) {\n\t\tconst indexes = blindCast(table).indexes;\n\t\tfor (const index of indexes ?? []) if (index.expression !== void 0 || index.where !== void 0) throw sqliteError(\"CONTRACT.ARGUMENT_INVALID\", `SQLite does not support expression or partial indexes: index \"${index.name ?? \"<unnamed>\"}\" on table \"${tableName}\" declares ${index.expression !== void 0 ? \"an expression\" : \"a where predicate\"}. Use a fields-only index, or author this index against a Postgres target.`);\n\t}\n}\nfunction buildSqliteNamespace(input) {\n\trejectSqlBodyIndexes(input);\n\tif (input.id !== UNBOUND_NAMESPACE_ID) throw sqliteError(\"CONTRACT.NAMESPACE_INVALID\", `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${input.id}\").`, { meta: { received: input.id } });\n\tconst tableKind = input.entries[\"table\"];\n\tconst tableCount = tableKind !== void 0 ? Object.keys(tableKind).length : 0;\n\tconst hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== \"table\");\n\tif (tableCount === 0 && !hasUnknownKinds) return SqliteUnboundDatabase.instance;\n\treturn new SqliteDatabase({\n\t\tid: input.id,\n\t\tentries: input.entries\n\t});\n}\n/**\n* Target-supplied `Namespace` factory the SQLite target plumbs through\n* `defineContract({ createNamespace })`. SQLite has only one\n* effective namespace slot — the framework `UNBOUND_NAMESPACE_ID`\n* sentinel — so the factory always returns the singleton or a fresh\n* `SqliteDatabase` for the unbound slot with tables. The SQL family's\n* defensive validation in `defineContract` already rejects\n* user-declared SQLite namespaces, so this throw is a structural\n* safety net rather than a user-facing surface.\n*/\nfunction sqliteCreateNamespace(input) {\n\treturn buildSqliteNamespace(input);\n}\n//#endregion\n//#region src/core/sqlite-contract-serializer.ts\n/**\n* SQLite target `ContractSerializer` concretion. Mirrors the Postgres\n* shape: inherits the full SQL-family deserialization pipeline and\n* materialises namespace entries as SQLite database concretions that\n* expose `qualifyTable()` for runtime SQL rendering.\n*/\nvar SqliteContractSerializer = class extends SqlContractSerializerBase {\n\tconstructor() {\n\t\tsuper(/* @__PURE__ */ new Map());\n\t}\n\thydrateSqlNamespaceEntry(nsId, raw) {\n\t\treturn buildSqliteNamespace(blindCast(super.hydrateSqlNamespaceEntry(nsId, raw)));\n\t}\n\tserializeContract(contract) {\n\t\tconst { storage, ...rest } = contract;\n\t\tconst namespacesJson = {};\n\t\tfor (const [nsId, ns] of Object.entries(storage.namespaces)) namespacesJson[nsId] = {\n\t\t\tid: ns.id,\n\t\t\tentries: this.serializeNamespaceEntries(ns.entries)\n\t\t};\n\t\treturn blindCast({\n\t\t\t...rest,\n\t\t\tstorage: {\n\t\t\t\tstorageHash: String(storage.storageHash),\n\t\t\t\tnamespaces: namespacesJson,\n\t\t\t\t...storage.types !== void 0 ? { types: this.serializeJsonObject(storage.types) } : {}\n\t\t\t}\n\t\t});\n\t}\n};\n//#endregion\n//#region src/core/sqlite-contract-view.ts\nconst SqliteContractView = {\n\t/** Wrap an already-deserialized SQLite contract in a view. */\n\tfrom(contract) {\n\t\treturn buildSqlSingleNamespaceView(contract);\n\t},\n\t/** Deserialize a SQLite contract JSON envelope and wrap it in a view. */\n\tfromJson(json) {\n\t\treturn buildSqlSingleNamespaceView(new SqliteContractSerializer().deserializeContract(json));\n\t}\n};\n//#endregion\nexport { sqliteCreateNamespace as i, SqliteContractSerializer as n, SqliteUnboundDatabase as r, SqliteContractView as t };\n\n//# sourceMappingURL=sqlite-contract-view-BrXalcTm.mjs.map"],"mappings":"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"}

package/dist/{sqlite-migration-DckJS_3w-BIKXWN5h.mjs → sqlite-migration-Bz7SwolX-CHLtwGNa.mjs}

@@ -1,23 +1,24 @@
 import { n as sqliteError, t as errorSqliteMigrationStackMissing } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
 import { n as SQLITE_NOW_EXPRESSION } from "./datetime-text-Bniwehv--Ddt3VS4z.mjs";
 import { n as sqliteResolveDefault } from "./default-normalizer-Ch3VFnEH-C-h1XtlJ.mjs";
-import { _ as sqliteIdentifiersCollide, a as DropColumnCall, d as buildColumnTypeSql, f as buildRecreatePostchecks, g as sqliteDefaultToDdlColumnDefault, h as renderDefaultLiteral, i as DataTransformCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, p as buildRecreateSummary, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as RenameTableCall } from "./op-factory-call-Bwp3QS4h-MwflmSX3.mjs";
+import { _ as renameTableSteps, a as DropColumnCall, b as sqliteIdentifiersCollide, d as RenameTableCall, f as buildColumnTypeSql, h as indexReplacementCalls, i as DataTransformCall, l as RecreateTableCall, m as buildRecreateSummary, n as CreateIndexCall, o as DropIndexCall, p as buildRecreatePostchecks, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as RenameColumnCall, v as renderDefaultLiteral, y as sqliteDefaultToDdlColumnDefault } from "./op-factory-call-Cwsf4slr-DRGuq5SV.mjs";
 import { t as CONTROL_TABLE_NAMES } from "./control-tables-D_o8dKRB-BXi43noL.mjs";
-import { n as SqliteContractView } from "./sqlite-contract-view-BYR10usg-BteDAUZr.mjs";
+import { n as SqliteContractView } from "./sqlite-contract-view-BrXalcTm-DYDH4LQC.mjs";
 import { DdlColumn, ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { diffSchemas, issueOutcome, orderIssuesByDependencies } from "@prisma/orm-framework/components/control";
-import { entityAt } from "@prisma/orm-framework/components/ir";
-import { RelationalSchemaNodeKind, SqlIndexIR, SqlSchemaIR, contractDefaultRefusal, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
+import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma/orm-framework/components/ir";
+import { PrimaryKey, RelationalSchemaNodeKind, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlTableIR, SqlUniqueIR, contractDefaultRefusal, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { applyTableRename, contractToSchemaIR, sqlTypeLookupsOf } from "@prisma/orm-family-sql/family/control";
+import { contractToSchemaIR, resolveColumnRenameAgainst, resolveTableRenameAgainst, sqlTypeLookupsOf, unmatchedColumnRename, unmatchedTableRename } from "@prisma/orm-family-sql/family/control";
 import { verifySqlSchemaByDiff } from "@prisma/orm-family-sql/family/diff";
-import { parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
 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/3-targets/sqlite/dist/sqlite-migration-DckJS_3w.mjs
+//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-migration-Bz7SwolX.mjs
 /** Renders a column default for the SQLite dialect. */
 function sqliteRenderDefault(def, column) {
 	if (def.kind === "function") {
@@ -107,13 +108,17 @@ function diffSqliteSchema(input) {
 function buildSqlitePlanDiff(input) {
 	const types = sqlTypeLookupsOf(input.frameworkComponents);
 	const expected = sqliteContractToSchema(input.contract, types);
-	const actual = new SqlSchemaIR(withRecordKeyNames(input.actualSchema));
+	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`,
@@ -270,33 +275,33 @@ function tableConstraintsFromNode(table, hasInlinePk) {
 * 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 now (type AND nullability
-* compared together by `SqlColumnIR.isEqualTo`), so this reads both fields
-* off the node pair directly rather than trusting a separate issue kind per
-* attribute: a type change is always destructive; a pure nullability change
-* is destructive when tightening (NOT NULL required) and widening when
-* relaxing.
+* 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;
+}
 function classifyNodeIssue(issue) {
 	const node = issue.expected ?? issue.actual;
 	if (node === void 0) return null;
 	switch (blindCast(node).nodeKind) {
-		case RelationalSchemaNodeKind.column: {
+		case RelationalSchemaNodeKind.column:
 			if (issueOutcome(issue) !== "not-equal") return null;
-			const expected = blindCast(issue.expected);
-			if (columnTypeChanged(expected, blindCast(issue.actual))) return "destructive";
-			return expected.nullable ? "widening" : "destructive";
-		}
-		case RelationalSchemaNodeKind.columnDefault: return issueOutcome(issue) === "not-expected" ? "destructive" : "widening";
+			return columnTypeChanged(blindCast(issue.expected), blindCast(issue.actual)) ? "destructive" : "widening";
+		case RelationalSchemaNodeKind.columnDefault:
 		case RelationalSchemaNodeKind.primaryKey:
 		case RelationalSchemaNodeKind.foreignKey:
-		case RelationalSchemaNodeKind.unique: return "destructive";
+		case RelationalSchemaNodeKind.unique: return "widening";
 		default: return null;
 	}
 }
 /**
 * Groups recreate-eligible issues by table, decides per-table operation class
-* (destructive wins over widening), and emits one `RecreateTableCall` per
+* (destructive wins over widening, and a recreate that leaves a live column
+* out of the new table loses its values, so it is destructive), and emits one `RecreateTableCall` per
 * table. Returns unchanged-or-smaller issue list — issues the strategy
 * consumed are removed so `mapNodeIssueToCall` doesn't double-handle them.
 *
@@ -313,14 +318,17 @@ const recreateTableStrategy = (issues, ctx) => {
 		if (!cls) continue;
 		const tableName = issue.path[1];
 		if (tableName === void 0) continue;
-		const entry = byTable.get(tableName);
-		if (entry) {
-			entry.issues.push(issue);
-			if (cls === "destructive") entry.hasDestructive = true;
-		} else byTable.set(tableName, {
-			issues: [issue],
-			hasDestructive: cls === "destructive"
-		});
+		const entry = byTable.get(tableName) ?? {
+			issues: [],
+			hasDestructive: false,
+			lossyColumns: []
+		};
+		entry.issues.push(issue);
+		if (cls === "destructive") {
+			entry.hasDestructive = true;
+			entry.lossyColumns.push(columnNameOf(issue));
+		}
+		byTable.set(tableName, entry);
 		consumed.add(issue);
 	}
 	if (byTable.size === 0) return { kind: "no_match" };
@@ -329,7 +337,8 @@ const recreateTableStrategy = (issues, ctx) => {
 		const expectedTable = ctx.expected.tables[tableName];
 		const actualTable = ctx.actual.tables[tableName];
 		if (!expectedTable || !actualTable) continue;
-		const operationClass = entry.hasDestructive ? "destructive" : "widening";
+		const leavesColumnsOut = Object.keys(actualTable.columns).some((column) => !Object.hasOwn(expectedTable.columns, column));
+		const operationClass = entry.hasDestructive || leavesColumnsOut ? "destructive" : "widening";
 		const tableSpec = tableSpecFromNode(expectedTable, ctx.types);
 		const indexes = expectedTable.indexes.map((idx) => ({
 			name: idx.name,
@@ -343,7 +352,7 @@ const recreateTableStrategy = (issues, ctx) => {
 			summary: buildRecreateSummary(tableName, entry.issues),
 			postchecks: buildRecreatePostchecks(tableName, entry.issues, tableSpec),
 			operationClass
-		}));
+		}, entry.lossyColumns));
 	}
 	return {
 		kind: "match",
@@ -366,11 +375,10 @@ const recreateTableStrategy = (issues, ctx) => {
 * recipe slot in strategy order (backfill first, recreate second), which
 * matches the required execution order.
 *
-* Mirrors Postgres's `nullableTighteningCallStrategy` / `'data'`-class
-* gating. When `'data'` is not in the policy (the default `db update` /
-* `db init` path), the strategy short-circuits and the recreate alone
-* runs with its current destructive-class gating — preserving today's
-* behavior where a tightening blows up at runtime if NULLs are present.
+* Mirrors Postgres's `nullableTighteningCallStrategy`. When `'data'` is not
+* in the policy (the default `db update` / `db init` path), the strategy
+* short-circuits and the recreate alone runs, failing at runtime if NULLs
+* are present.
 */
 const nullabilityTighteningBackfillStrategy = (issues, ctx) => {
 	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
@@ -690,6 +698,13 @@ function renamedTableIndex(renamedTables) {
 	};
 }
 /**
+* 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);
@@ -707,29 +722,251 @@ function pairIndexReplacements(issues, matches) {
 			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 {
-		calls: [...pairs.map(({ old }) => new DropIndexCall(old.tableName, old.index.name)), ...pairs.map(({ replacement }) => new CreateIndexCall(replacement.tableName, replacement.index.name, replacement.index.columns ?? []))],
+		replacements,
+		calls: indexReplacementCalls(replacements),
 		consumed: new Set(pairs.flatMap(({ old, replacement }) => [old.issue, replacement.issue]))
 	};
 }
 /**
-* The calls a migration's `renameTable` emits: the table rename, then a drop of each wire-named index whose prefix derives from the old table name and a create of it under the new name, since SQLite cannot rename an index. SQLite names no primary key, unique constraint or foreign key the contract leaves unnamed, so those need nothing. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
+* 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] : []
+	};
+}
+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 sqliteTableRenameCalls(input) {
-	const applied = applyTableRename({
-		startContract: input.startContract,
-		endContract: input.endContract,
-		rename: input.rename,
-		renameTableReferences: void 0
+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);
+	};
+}
+function withColumnName(column, name) {
+	return new SqlColumnIR({
+		name,
+		nativeType: column.nativeType,
+		nullable: column.nullable,
+		...ifDefined("default", column.default),
+		...ifDefined("annotations", column.annotations),
+		...ifDefined("many", column.many),
+		...ifDefined("resolvedNativeType", column.resolvedNativeType),
+		...ifDefined("resolvedDefault", column.resolvedDefault),
+		...ifDefined("authoredDefault", column.authoredDefault),
+		...ifDefined("codecRef", column.codecRef),
+		...ifDefined("codecBaseNativeType", column.codecBaseNativeType),
+		...ifDefined("dataType", column.dataType),
+		...ifDefined("toCanonicalForm", column.toCanonicalForm)
+	});
+}
+/**
+* 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)
 	});
-	if (!applied.ok) throw applied.failure;
-	const { rename } = applied.value;
+}
+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 : withColumnName(column, 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();
+}
+/**
+* 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.endContract,
-		actualSchema: sqliteContractToSchema(applied.value.contract, sqlTypeLookupsOf(input.frameworkComponents)),
+		contract: input.contract,
+		actualSchema: renameColumnInSqliteSchema(input.previous, {
+			table,
+			from,
+			to
+		}),
 		frameworkComponents: input.frameworkComponents
 	});
-	return [new RenameTableCall(rename.from, rename.to), ...pairIndexReplacements(coalesceSubtreeIssues(issues), renamedTableIndex(/* @__PURE__ */ new Set([rename.to]))).calls];
+	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`
@@ -763,6 +1000,8 @@ var SqliteMigration = class extends Migration {
 	*/
 	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);
@@ -808,20 +1047,76 @@ var SqliteMigration = class extends Migration {
 		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, read from this migration's start and end contracts. Spread the result into `operations`: `...this.renameTable({ table: 'userProfile', to: 'UserProfile' })`. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
+	* 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");
-		return sqliteTableRenameCalls({
-			startContract: this.startContract,
-			endContract: this.endContract,
-			rename: {
-				namespaceId: void 0,
-				from: options.table,
-				to: options.to
-			},
+		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()
-		}).map(async (call) => call.toOp(adapter));
+		});
+		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, options.column).toOp(this.controlAdapterFor("addColumn"));
@@ -840,6 +1135,6 @@ var SqliteMigration = class extends Migration {
 	}
 };
 //#endregion
-export { diffSqliteSchema as a, pairIndexReplacements as c, sqlitePlannerStrategies as d, verifySqliteDatabaseSchema as f, conflictForDisallowedCall as i, planIssues as l, buildSqlitePlanDiff as n, indexNameCaseChange as o, coalesceSubtreeIssues as r, issueNode as s, SqliteMigration as t, sqliteContractToSchema as u };
+export { sqliteSchemaTables as _, createWorkingSchema as a, 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, sqliteTableRenameCall as v, verifySqliteDatabaseSchema as y };
 
-//# sourceMappingURL=sqlite-migration-DckJS_3w-BIKXWN5h.mjs.map
+//# sourceMappingURL=sqlite-migration-Bz7SwolX-CHLtwGNa.mjs.map