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

package/dist/{migration-Ccuxti02.d.mts → migration-CGyA6YVp.d.mts}

@@ -1,5 +1,5 @@
 import { t as Op } from "./tables-CvLOKCiJ-Ca1eFkWN.mjs";
-import "./sqlite-migration-BSUZhMDG-DZU3d7bZ.mjs";
+import "./sqlite-migration-Kqf6dAgP-DDc4wuXM.mjs";
 import { col as col$1, fn as fn$1, foreignKey, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
 import { placeholder } from "@prisma/orm-framework/errors/migration";
 import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
@@ -40,4 +40,4 @@ declare function dataTransform(opts: DataTransformOptions): Op;
 declare function rawSql(op: Op): Op;
 //#endregion
 export { fn$1 as a, placeholder as c, unique as d, dataTransform as i, primaryKey as l, MigrationCLI as n, foreignKey as o, col$1 as r, lit$1 as s, DataTransformOptions as t, rawSql as u };
-//# sourceMappingURL=migration-Ccuxti02.d.mts.map
+//# sourceMappingURL=migration-CGyA6YVp.d.mts.map

package/dist/{migration-Ccuxti02.d.mts.map → migration-CGyA6YVp.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"migration-Ccuxti02.d.mts","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/migration.d.mts"],"mappings":";;;;;;;UAMU;;WAEC;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;WASA;;iBAEM,cAAc,MAAM,uBAAuB;;;;;;;;;;iBAU3C,OAAO,IAAI,KAAK"}
+{"version":3,"file":"migration-CGyA6YVp.d.mts","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/migration.d.mts"],"mappings":";;;;;;;UAMU;;WAEC;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;WASA;;iBAEM,cAAc,MAAM,uBAAuB;;;;;;;;;;iBAU3C,OAAO,IAAI,KAAK"}

package/dist/{migration-65TwrHP0.mjs → migration-DNLfgvkg.mjs}

@@ -1,5 +1,5 @@
 import { t as buildTargetDetails } from "./planner-target-details-CIQ789Gc-C5U4yVY9.mjs";
-import { v as step } from "./op-factory-call-Bwp3QS4h-MwflmSX3.mjs";
+import { x as step } from "./op-factory-call-Cwsf4slr-DRGuq5SV.mjs";
 import { col as col$1, fn as fn$1, foreignKey, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
 import { placeholder } from "@prisma/orm-framework/errors/migration";
 import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
@@ -44,4 +44,4 @@ function rawSql(op) {
 //#endregion
 export { foreignKey as a, primaryKey as c, fn$1 as i, rawSql as l, col$1 as n, lit$1 as o, dataTransform as r, placeholder as s, MigrationCLI as t, unique as u };
 
-//# sourceMappingURL=migration-65TwrHP0.mjs.map
+//# sourceMappingURL=migration-DNLfgvkg.mjs.map

package/dist/{migration-65TwrHP0.mjs.map → migration-DNLfgvkg.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"migration-65TwrHP0.mjs","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/migration.mjs"],"sourcesContent":["import { h as step } from \"./op-factory-call-Bwp3QS4h.mjs\";\nimport { t as SqliteMigration } from \"./sqlite-migration-DckJS_3w.mjs\";\nimport { t as buildTargetDetails } from \"./planner-target-details-CIQ789Gc.mjs\";\nimport { placeholder } from \"@internal/errors/migration\";\nimport { col, fn, foreignKey, lit, primaryKey, unique } from \"@internal/sql-relational-core/contract-free\";\nimport { MigrationCLI } from \"@internal/cli/migration-cli\";\n//#region src/core/migrations/operations/data-transform.ts\n/**\n* User-facing `dataTransform` factory for the SQLite migration authoring\n* surface. Invoked directly inside a `migration.ts` file to supply a\n* user-authored SQL statement that runs with operation class `'data'`.\n*\n* Typical use: the planner emits a `DataTransformCall` stub when a NOT NULL\n* tightening requires a backfill. The rendered `migration.ts` exposes the\n* backfill as a `placeholder(\"…\")` slot the user fills in with an\n* `UPDATE … WHERE col IS NULL` statement. The filled-in `dataTransform(...)`\n* invocation returns a runnable operation the runner executes before the\n* subsequent recreate-table op copies data into the tightened schema.\n*/\nfunction dataTransform(opts) {\n\treturn {\n\t\tid: opts.id,\n\t\tlabel: opts.label,\n\t\tsummary: opts.description,\n\t\toperationClass: \"data\",\n\t\ttarget: {\n\t\t\tid: \"sqlite\",\n\t\t\tdetails: buildTargetDetails(\"table\", opts.table)\n\t\t},\n\t\tprecheck: [],\n\t\texecute: [step(opts.description, opts.run())],\n\t\tpostcheck: []\n\t};\n}\n//#endregion\n//#region src/core/migrations/operations/raw.ts\n/**\n* Identity factory for an already-materialized\n* `SqlMigrationPlanOperation<SqlitePlanTargetDetails>`. Mirrors the Postgres\n* `rawSql` factory: the planner uses this to carry ops produced by SQL-family\n* paths (codec lifecycle hooks, raw-SQL escape hatches) alongside structured\n* call IR without reverse-engineering their shape.\n*/\nfunction rawSql(op) {\n\treturn op;\n}\n//#endregion\nexport { SqliteMigration as Migration, MigrationCLI, col, dataTransform, fn, foreignKey, lit, placeholder, primaryKey, rawSql, unique };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAS,cAAc,MAAM;CAC5B,OAAO;EACN,IAAI,KAAK;EACT,OAAO,KAAK;EACZ,SAAS,KAAK;EACd,gBAAgB;EAChB,QAAQ;GACP,IAAI;GACJ,SAAS,mBAAmB,SAAS,KAAK,KAAK;EAChD;EACA,UAAU,CAAC;EACX,SAAS,CAAC,KAAK,KAAK,aAAa,KAAK,IAAI,CAAC,CAAC;EAC5C,WAAW,CAAC;CACb;AACD;;;;;;;;AAUA,SAAS,OAAO,IAAI;CACnB,OAAO;AACR"}
+{"version":3,"file":"migration-DNLfgvkg.mjs","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/migration.mjs"],"sourcesContent":["import { v as step } from \"./op-factory-call-Cwsf4slr.mjs\";\nimport { t as SqliteMigration } from \"./sqlite-migration-Bz7SwolX.mjs\";\nimport { t as buildTargetDetails } from \"./planner-target-details-CIQ789Gc.mjs\";\nimport { placeholder } from \"@internal/errors/migration\";\nimport { col, fn, foreignKey, lit, primaryKey, unique } from \"@internal/sql-relational-core/contract-free\";\nimport { MigrationCLI } from \"@internal/cli/migration-cli\";\n//#region src/core/migrations/operations/data-transform.ts\n/**\n* User-facing `dataTransform` factory for the SQLite migration authoring\n* surface. Invoked directly inside a `migration.ts` file to supply a\n* user-authored SQL statement that runs with operation class `'data'`.\n*\n* Typical use: the planner emits a `DataTransformCall` stub when a NOT NULL\n* tightening requires a backfill. The rendered `migration.ts` exposes the\n* backfill as a `placeholder(\"…\")` slot the user fills in with an\n* `UPDATE … WHERE col IS NULL` statement. The filled-in `dataTransform(...)`\n* invocation returns a runnable operation the runner executes before the\n* subsequent recreate-table op copies data into the tightened schema.\n*/\nfunction dataTransform(opts) {\n\treturn {\n\t\tid: opts.id,\n\t\tlabel: opts.label,\n\t\tsummary: opts.description,\n\t\toperationClass: \"data\",\n\t\ttarget: {\n\t\t\tid: \"sqlite\",\n\t\t\tdetails: buildTargetDetails(\"table\", opts.table)\n\t\t},\n\t\tprecheck: [],\n\t\texecute: [step(opts.description, opts.run())],\n\t\tpostcheck: []\n\t};\n}\n//#endregion\n//#region src/core/migrations/operations/raw.ts\n/**\n* Identity factory for an already-materialized\n* `SqlMigrationPlanOperation<SqlitePlanTargetDetails>`. Mirrors the Postgres\n* `rawSql` factory: the planner uses this to carry ops produced by SQL-family\n* paths (codec lifecycle hooks, raw-SQL escape hatches) alongside structured\n* call IR without reverse-engineering their shape.\n*/\nfunction rawSql(op) {\n\treturn op;\n}\n//#endregion\nexport { SqliteMigration as Migration, MigrationCLI, col, dataTransform, fn, foreignKey, lit, placeholder, primaryKey, rawSql, unique };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAS,cAAc,MAAM;CAC5B,OAAO;EACN,IAAI,KAAK;EACT,OAAO,KAAK;EACZ,SAAS,KAAK;EACd,gBAAgB;EAChB,QAAQ;GACP,IAAI;GACJ,SAAS,mBAAmB,SAAS,KAAK,KAAK;EAChD;EACA,UAAU,CAAC;EACX,SAAS,CAAC,KAAK,KAAK,aAAa,KAAK,IAAI,CAAC,CAAC;EAC5C,WAAW,CAAC;CACb;AACD;;;;;;;;AAUA,SAAS,OAAO,IAAI;CACnB,OAAO;AACR"}

package/dist/{op-factory-call-B_WuATMN.d.mts → op-factory-call-BsGdsm8Y.d.mts}

@@ -13,6 +13,8 @@ declare abstract class SqliteOpFactoryCallNode extends TsExpression implements O
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
   abstract toOp(lowerer?: Lowerer): Op | Promise<Op>;
+  /** The operations this call lowers to, in order: one, unless the call carries companions. */
+  toOps(lowerer?: ExecuteRequestLowerer): readonly (Op | Promise<Op>)[];
   importRequirements(): readonly ImportRequirement[];
   protected freeze(): void;
 }
@@ -38,6 +40,13 @@ declare class DropTableCall extends SqliteOpFactoryCallNode {
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
 }
+/** An index SQLite cannot rename, dropped and created again under its new name. */
+interface IndexReplacement {
+  readonly drop: DropIndexCall;
+  readonly create: CreateIndexCall;
+}
+/** A call a table or column rename carries to replace an index whose name derives from the old name. */
+type RenameCompanionCall = DropIndexCall | CreateIndexCall;
 declare class RenameTableCall extends SqliteOpFactoryCallNode {
   readonly factoryName: "renameTable";
   readonly operationClass: "widening";
@@ -45,7 +54,38 @@ declare class RenameTableCall extends SqliteOpFactoryCallNode {
   /** The new name: the table's contract-side identity after the rename. */
   readonly tableName: string;
   readonly label: string;
-  constructor(oldTableName: string, tableName: string);
+  /** The indexes named after the old table, which SQLite cannot rename, so it replaces them. */
+  readonly indexReplacements: readonly IndexReplacement[];
+  /**
+   * The replacements' drops, then their creates. They run after the table rename and are never
+   * rendered on their own.
+   */
+  readonly companions: readonly RenameCompanionCall[];
+  constructor(oldTableName: string, tableName: string, indexReplacements: readonly IndexReplacement[]);
+  /** The id of the operation this call lowers to. */
+  get operationId(): string;
+  toOps(lowerer?: ExecuteRequestLowerer): readonly Promise<Op>[];
+  toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+declare class RenameColumnCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "renameColumn";
+  readonly operationClass: "widening";
+  readonly tableName: string;
+  readonly oldColumnName: string;
+  /** The new name: the column's contract-side identity after the rename. */
+  readonly columnName: string;
+  readonly label: string;
+  /** The indexes on the column whose wire names change, which SQLite cannot rename. */
+  readonly indexReplacements: readonly IndexReplacement[];
+  /**
+   * The replacements' drops, then their creates. They run after the column rename and are never
+   * rendered on their own.
+   */
+  readonly companions: readonly RenameCompanionCall[];
+  constructor(tableName: string, oldColumnName: string, columnName: string, indexReplacements: readonly IndexReplacement[]);
+  toOps(lowerer?: ExecuteRequestLowerer): readonly Promise<Op>[];
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
@@ -60,6 +100,11 @@ declare class RecreateTableCall extends SqliteOpFactoryCallNode {
   readonly summary: string;
   readonly postchecks: readonly RecreatePostcheck[];
   readonly label: string;
+  /**
+   * The columns whose values the copy can change, because their type changes. The planner reads
+   * them to name what the recreate loses; they never reach the operation or `migration.ts`.
+   */
+  readonly lossyColumns: readonly string[];
   constructor(args: {
     tableName: string;
     contractTable: SqliteTableSpec;
@@ -68,7 +113,7 @@ declare class RecreateTableCall extends SqliteOpFactoryCallNode {
     summary: string;
     postchecks: readonly RecreatePostcheck[];
     operationClass: MigrationOperationClass;
-  });
+  }, lossyColumns?: readonly string[]);
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
@@ -104,17 +149,21 @@ declare class CreateIndexCall extends SqliteOpFactoryCallNode {
   readonly columns: readonly string[];
   readonly label: string;
   constructor(tableName: string, indexName: string, columns: readonly string[]);
+  /** The id of the operation this call lowers to. */
+  get operationId(): string;
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
 }
 declare class DropIndexCall extends SqliteOpFactoryCallNode {
   readonly factoryName: "dropIndex";
-  readonly operationClass: "destructive";
+  readonly operationClass: "widening";
   readonly tableName: string;
   readonly indexName: string;
   readonly label: string;
   constructor(tableName: string, indexName: string);
+  /** The id of the operation this call lowers to. */
+  get operationId(): string;
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
@@ -127,7 +176,7 @@ declare class DropIndexCall extends SqliteOpFactoryCallNode {
  * any future strategy that needs a placeholder data step can construct one
  * with its own id/label.
  *
- * `toOp()` always throws `MIGRATION.UNFILLED_PLACEHOLDER`: the planner cannot lower a stubbed
+ * `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.
  */
@@ -139,7 +188,7 @@ declare class DataTransformCall extends SqliteOpFactoryCallNode {
   readonly tableName: string;
   readonly columnName: string;
   constructor(id: string, label: string, tableName: string, columnName: string);
-  toOp(_lowerer?: Lowerer): Op;
+  toOp(_lowerer?: Lowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
 }
@@ -161,7 +210,7 @@ declare class RawSqlCall extends SqliteOpFactoryCallNode {
   toOp(_lowerer?: Lowerer): Op;
   renderTypeScript(): string;
 }
-type SqliteOpFactoryCall = CreateTableCall | DropTableCall | RecreateTableCall | RenameTableCall | AddColumnCall | DropColumnCall | CreateIndexCall | DropIndexCall | DataTransformCall | RawSqlCall;
+type SqliteOpFactoryCall = CreateTableCall | DropTableCall | RecreateTableCall | RenameTableCall | RenameColumnCall | AddColumnCall | DropColumnCall | CreateIndexCall | DropIndexCall | DataTransformCall | RawSqlCall;
 //#endregion
-export { DropColumnCall as a, RawSqlCall as c, SqliteOpFactoryCall as d, DataTransformCall as i, RecreateTableCall as l, CreateIndexCall as n, DropIndexCall as o, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameTableCall as u };
-//# sourceMappingURL=op-factory-call-B_WuATMN.d.mts.map
+export { DropColumnCall as a, RawSqlCall as c, RenameTableCall as d, SqliteOpFactoryCall as f, DataTransformCall as i, RecreateTableCall as l, CreateIndexCall as n, DropIndexCall as o, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameColumnCall as u };
+//# sourceMappingURL=op-factory-call-BsGdsm8Y.d.mts.map

package/dist/op-factory-call-BsGdsm8Y.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-BsGdsm8Y.d.mts","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/op-factory-call.d.mts"],"mappings":";;;;;;;;;KAQK,KAAK,0BAA0B;uBACb,gCAAgC,wBAAwB;oBAC3D;oBACA,gBAAgB;oBAChB;WACT,KAAK,UAAU,UAAU,KAAK,QAAQ;;EAE/C,MAAM,UAAU,kCAAkC,KAAK,QAAQ;EAC/D,+BAA+B;YACrB;;cAEE,wBAAwB;WAC3B;WACA;WACA;WACA,kBAAkB;WAClB,sBAAsB;WACtB;EACT,YAAY,mBAAmB,kBAAkB,aAAa,uBAAuB;EACrF,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,sBAAsB;WACzB;WACA;WACA;WACA;EACT,YAAY;EACZ,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;;UAGvB;WACC,MAAM;WACN,QAAQ;;;KAGd,sBAAsB,gBAAgB;cAC7B,wBAAwB;WAC3B;WACA;WACA;;WAEA;WACA;;WAEA,4BAA4B;;;;;WAK5B,qBAAqB;EAC9B,YAAY,sBAAsB,mBAAmB,4BAA4B;;MAE7E;EACJ,MAAM,UAAU,iCAAiC,QAAQ;EACzD,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,yBAAyB;WAC5B;WACA;WACA;WACA;;WAEA;WACA;;WAEA,4BAA4B;;;;;WAK5B,qBAAqB;EAC9B,YAAY,mBAAmB,uBAAuB,oBAAoB,4BAA4B;EACtG,MAAM,UAAU,iCAAiC,QAAQ;EACzD,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,0BAA0B;WAC7B;WACA,gBAAgB;WAChB;WACA,eAAe;WACf;WACA,kBAAkB;WAClB;WACA,qBAAqB;WACrB;;;;;WAKA;EACT,YAAY;IACV;IACA,eAAe;IACf;IACA,kBAAkB;IAClB;IACA,qBAAqB;IACrB,gBAAgB;KACf;EACH,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,sBAAsB;WACzB;WACA;WACA;WACA;WACA,QAAQ;WACR;EACT,YAAY,mBAAmB,QAAQ;EACvC,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,uBAAuB;WAC1B;WACA;WACA;WACA;WACA;EACT,YAAY,mBAAmB;EAC/B,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,wBAAwB;WAC3B;WACA;WACA;WACA;WACA;WACA;EACT,YAAY,mBAAmB,mBAAmB;;MAE9C;EACJ,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;cAEnB,sBAAsB;WACzB;WACA;WACA;WACA;WACA;EACT,YAAY,mBAAmB;;MAE3B;EACJ,KAAK,UAAU,wBAAwB,QAAQ;EAC/C;EACA,+BAA+B;;;;;;;;;;;;;;cAcnB,0BAA0B;WAC7B;WACA;WACA;WACA;WACA;WACA;EACT,YAAY,YAAY,eAAe,mBAAmB;EAC1D,KAAK,WAAW,UAAU,QAAQ;EAClC;EACA,+BAA+B;;;;;;;;;;;cAWnB,mBAAmB;WACtB;WACA,gBAAgB;WAChB;WACA,IAAI;EACb,YAAY,IAAI;EAChB,KAAK,WAAW,UAAU;EAC1B;;KAEG,sBAAsB,kBAAkB,gBAAgB,oBAAoB,kBAAkB,mBAAmB,gBAAgB,iBAAiB,kBAAkB,gBAAgB,oBAAoB"}

package/dist/{op-factory-call-Bwp3QS4h-MwflmSX3.mjs → op-factory-call-Cwsf4slr-DRGuq5SV.mjs}

@@ -1,9 +1,9 @@
 import { o as sqliteInteger } from "./data-types-pFQMl37_-B-3aK_wd.mjs";
 import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
 import { n as decodeSqliteDatetime, r as encodeSqliteDatetime } from "./codecs-BctEWIFt-DgMd3dUl.mjs";
-import { i as tableExistsAst, n as createTable, r as indexExistsAst, t as columnExistsAst } from "./ddl-CXduXyOT-nlDP6DGx.mjs";
-import { r as stripOuterParens } from "./default-normalizer-Ch3VFnEH-C-h1XtlJ.mjs";
+import { a as tableExistsAst, i as indexExistsAst, n as columnNameTakenAst, o as tableNameTakenAst, r as createTable, t as columnExistsAst } from "./ddl-CDoa1Ehx-BOT670XL.mjs";
 import { n as quoteIdentifier, t as escapeLiteral } from "./sql-utils-C2O4zVkP-Dz3Hb85I.mjs";
+import { r as stripOuterParens } from "./default-normalizer-Ch3VFnEH-C-h1XtlJ.mjs";
 import { t as buildTargetDetails } from "./planner-target-details-CIQ789Gc-C5U4yVY9.mjs";
 import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, opaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -12,10 +12,10 @@ import { dataTypeParams, renderSqlTypeName, sqlDataTypeOfCodec } from "@prisma/o
 import { issueOutcome } from "@prisma/orm-framework/components/control";
 import { RelationalSchemaNodeKind } from "@prisma/orm-family-sql/schema-ir/types";
 import { assertNever } from "@prisma/orm-framework/utils/internal-error";
-import { errorMigrationOperationOptionRemoved, errorUnfilledPlaceholder } from "@prisma/orm-framework/errors/migration";
+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/3-targets/sqlite/dist/op-factory-call-Bwp3QS4h.mjs
+//#region ../../../3-targets/3-targets/sqlite/dist/op-factory-call-Cwsf4slr.mjs
 /**
 * Low-level DDL fragment builders for SQLite migrations.
 *
@@ -178,6 +178,39 @@ async function addColumn(tableName, column, lowerer) {
 		postcheck: [step(`verify column "${column.name}" exists`, present.sql, present.params)]
 	};
 }
+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 toAbsent = await lowerer.lowerToExecuteRequest(sqliteIdentifiersCollide(fromName, toName) ? 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), step(`ensure column "${toName}" does not exist on "${tableName}"`, toAbsent.sql, toAbsent.params)],
+		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), step(`verify column "${fromName}" no longer exists on "${tableName}"`, fromAbsent.sql, fromAbsent.params)]
+	};
+}
 async function tableExistsSteps(lowerer, tableName) {
 	const checks = tableExistsAst(tableName);
 	return {
@@ -451,6 +484,10 @@ function buildRecreatePostchecks(tableName, issues, spec) {
 }
 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,
@@ -461,6 +498,10 @@ var SqliteOpFactoryCallNode = class extends TsExpression {
 		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) {
 	if (!def) return "";
 	if (def.kind === "literal") return `lit(${jsonToTsSource(def.value)})`;
@@ -626,6 +667,10 @@ var DropTableCall = class extends SqliteOpFactoryCallNode {
 		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";
@@ -633,13 +678,29 @@ var RenameTableCall = class extends SqliteOpFactoryCallNode {
 	/** The new name: the table's contract-side identity after the rename. */
 	tableName;
 	label;
-	constructor(oldTableName, tableName) {
+	/** 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,
@@ -648,13 +709,14 @@ var RenameTableCall = class extends SqliteOpFactoryCallNode {
 		const fromChecks = tableExistsAst(this.oldTableName);
 		const toChecks = tableExistsAst(this.tableName);
 		const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.tablePresent());
-		const toAbsent = await lowerer.lowerToExecuteRequest(toChecks.tableAbsent());
+		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 = renameChangesOnlyCase(this.oldTableName, this.tableName) ? await lowerer.lowerToExecuteRequest(tableExistsAst(viaName).tableAbsent()) : void 0;
+		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: `renameTable.${this.oldTableName}`,
+			id: this.operationId,
 			label: this.label,
 			summary: `Renames table ${this.oldTableName} to ${this.tableName}, keeping its rows`,
 			operationClass: "widening",
@@ -664,7 +726,7 @@ var RenameTableCall = class extends SqliteOpFactoryCallNode {
 			},
 			precheck: [
 				step(`ensure table "${this.oldTableName}" exists`, fromPresent.sql, fromPresent.params),
-				step(`ensure table "${this.tableName}" does not exist`, toAbsent.sql, toAbsent.params),
+				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),
 				...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)]
 			],
 			execute: renameTableSteps(this.oldTableName, this.tableName),
@@ -678,6 +740,48 @@ var RenameTableCall = class extends SqliteOpFactoryCallNode {
 		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 [];
+	}
+};
 var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 	factoryName = "recreateTable";
 	operationClass;
@@ -688,8 +792,14 @@ var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 	summary;
 	postchecks;
 	label;
-	constructor(args) {
+	/**
+	* The columns whose values the copy can change, because their type changes. The planner reads
+	* them to name what the recreate loses; they never reach the operation or `migration.ts`.
+	*/
+	lossyColumns;
+	constructor(args, lossyColumns = []) {
 		super();
+		this.lossyColumns = Object.freeze([...lossyColumns]);
 		this.tableName = args.tableName;
 		this.contractTable = args.contractTable;
 		this.schemaColumnNames = args.schemaColumnNames;
@@ -818,6 +928,10 @@ var CreateIndexCall = class extends SqliteOpFactoryCallNode {
 		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,
@@ -828,7 +942,7 @@ var CreateIndexCall = class extends SqliteOpFactoryCallNode {
 		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
 		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
 		return {
-			id: `index.${this.tableName}.${this.indexName}`,
+			id: this.operationId,
 			label: `Create index ${this.indexName} on ${this.tableName}`,
 			summary: `Creates index ${this.indexName} on ${this.tableName}`,
 			operationClass: "additive",
@@ -850,7 +964,7 @@ var CreateIndexCall = class extends SqliteOpFactoryCallNode {
 };
 var DropIndexCall = class extends SqliteOpFactoryCallNode {
 	factoryName = "dropIndex";
-	operationClass = "destructive";
+	operationClass = "widening";
 	tableName;
 	indexName;
 	label;
@@ -861,6 +975,10 @@ var DropIndexCall = class extends SqliteOpFactoryCallNode {
 		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,
@@ -871,10 +989,10 @@ var DropIndexCall = class extends SqliteOpFactoryCallNode {
 		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
 		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
 		return {
-			id: `dropIndex.${this.tableName}.${this.indexName}`,
+			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: "destructive",
+			operationClass: "widening",
 			target: {
 				id: "sqlite",
 				details: buildTargetDetails("index", this.indexName, this.tableName)
@@ -899,7 +1017,7 @@ var DropIndexCall = class extends SqliteOpFactoryCallNode {
 * any future strategy that needs a placeholder data step can construct one
 * with its own id/label.
 *
-* `toOp()` always throws `MIGRATION.UNFILLED_PLACEHOLDER`: the planner cannot lower a stubbed
+* `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.
 */
@@ -919,7 +1037,7 @@ var DataTransformCall = class extends SqliteOpFactoryCallNode {
 		this.freeze();
 	}
 	toOp(_lowerer) {
-		throw errorUnfilledPlaceholder(this.label);
+		return unfilledPlaceholderOperation(this.label);
 	}
 	renderTypeScript() {
 		const slot = `${this.tableName}-${this.columnName}-backfill-sql`;
@@ -1013,6 +1131,6 @@ function renderPostcheck(postcheck) {
 	}));
 }
 //#endregion
-export { sqliteIdentifiersCollide as _, DropColumnCall as a, RawSqlCall as c, buildColumnTypeSql as d, buildRecreatePostchecks as f, sqliteDefaultToDdlColumnDefault as g, renderDefaultLiteral as h, DataTransformCall as i, RecreateTableCall as l, renameTableSteps as m, CreateIndexCall as n, DropIndexCall as o, buildRecreateSummary as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameTableCall as u, step as v };
+export { renameTableSteps as _, DropColumnCall as a, sqliteIdentifiersCollide as b, RawSqlCall as c, RenameTableCall as d, buildColumnTypeSql as f, isSqliteOpFactoryCall as g, indexReplacementCalls as h, DataTransformCall as i, RecreateTableCall as l, buildRecreateSummary as m, CreateIndexCall as n, DropIndexCall as o, buildRecreatePostchecks as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameColumnCall as u, renderDefaultLiteral as v, step as x, sqliteDefaultToDdlColumnDefault as y };
 
-//# sourceMappingURL=op-factory-call-Bwp3QS4h-MwflmSX3.mjs.map
+//# sourceMappingURL=op-factory-call-Cwsf4slr-DRGuq5SV.mjs.map