@voltro/database 0.84.0 → 0.86.0

package/dist/migrations/applier.js

@@ -0,0 +1,1085 @@
+import { isMysqlFamily as e, isSqliteFamily as t, quoteIdent as n } from "../dialect.js";
+import { sqliteDecimalStorageCheck as r, sqliteDecimalStorageShape as i } from "../sqliteDecimalStorage.js";
+import { decodeRowsForTable as a } from "../rowDecoder.js";
+import { fireSchemaChangeSeeds as o } from "../seed.js";
+import { sqlError as s } from "../sqlError.js";
+import { _voltroMigrationPlansTable as c, _voltroPluginMigrationsTable as l, _voltroSchemaOwnerTable as u } from "../frameworkTables.js";
+import { REPLACE_IN_PROGRESS_TABLE as d, _voltroReplaceInProgressTable as f } from "../replaceInProgress.js";
+import { pgIndexClauses as p } from "../indexStorage.js";
+import { formatDdlError as m } from "./ddlError.js";
+import { acquireMigrationLock as ee } from "./lock.js";
+import { MIGRATION_OPS_TABLE as h, SHADOW_COLUMN_SUFFIX as te, SHADOW_OLD_SUFFIX as g, SQLITE_REBUILD_SUFFIX as ne, _voltroMigrationOpsTable as re, dialectOf as _, migrationAtomicityFor as ie, opStillOutstanding as v, opTargetLabel as ae, resumeIdempotencyFor as y } from "./resumeLedger.js";
+import { mssqlJsonValueCheck as b } from "../mssqlJsonValueCheck.js";
+import { defaultArrayClause as x, defaultClause as S, defaultJsonClause as C, enumRenameBlocks as oe, enumTypeBlocks as se, extensionBlocks as ce, numericIdSql as w, sqlType as T } from "../migrate.js";
+import { runSqliteMigrationBatch as le } from "./sqliteMigrationBatch.js";
+import { declaredSnapshot as ue, snapshotColumn as E } from "./declaredSchema.js";
+import { DEPLOY_LEDGER_TABLE as de, _voltroDeploysTable as fe } from "./deployLedger.js";
+import { parseEnumCheck as D } from "./introspect.js";
+import { migrationTableExists as O } from "./migrationTableExists.js";
+import { bindSoftDropSnapshot as pe, readSoftDropSnapshot as me } from "./softDropSnapshot.js";
+import { limitClause as k } from "./sqlLimit.js";
+import { resolveMysqlEngine as A } from "./mysqlEngine.js";
+import { MYSQL_COLUMN_OR_INDEX_ABSENT as he, MYSQL_CONSTRAINT_ABSENT as ge, MYSQL_FOREIGN_KEY_EXISTS as _e, MYSQL_INDEX_EXISTS as ve, SQLITE_COLUMN_ABSENT as ye, isAlreadySatisfied as be } from "./idempotentDdl.js";
+import { withMigrationTransaction as xe } from "./transactionCause.js";
+import { renameMssqlCheck as Se } from "./renameMssqlCheck.js";
+import { alterColumnWithDependenciesMssql as Ce } from "./mssqlColumnDependencies.js";
+import { appliedAtValue as j } from "./appliedAtValue.js";
+import { Effect as M } from "effect";
+import { isDeepStrictEqual as we } from "node:util";
+import { randomUUID as Te } from "node:crypto";
+import { SqlClient as Ee } from "effect/sql";
+//#region src/migrations/applier.ts
+var De = (e, t) => `${t}(${e.precision ?? 38}, ${e.scale ?? 0})`, Oe = (e) => e.type === "text" && (e.hasDefault && e.defaultValue !== void 0 || e.oneOf !== void 0 && e.oneOf.length > 0), N = (e, t) => {
+	let n = e.type === "text" && e.maxLength !== void 0;
+	if (e.sqliteDecimalEncoding === void 0 && !n && !Oe(e) && !e.spatial && e.type !== "vector" && e.type !== "array" && e.type !== "enum") return;
+	let r = e.type === "vector" && e.vectorDim === void 0 ? "vector dimension" : e.type === "array" && e.arrayElement === void 0 ? "array element type" : e.type === "enum" && e.enumName === void 0 && e.enumValues === void 0 ? "enum name/values" : void 0;
+	if (r !== void 0) throw Error(`migration applier: cannot render '${e.name}' (${e.type}) — the schema snapshot carries no ${r}. Rendering it as 'text' would emit DDL that applies successfully and changes nothing, so this fails instead. This is a framework bug: declaredSchema.ts must carry the parameter into the ColumnSnapshot.`);
+	return T(e, t);
+}, P = (e) => {
+	let t = N(e, "postgres");
+	return t === void 0 ? ke(e) : t;
+}, ke = (e) => {
+	switch (e.type) {
+		case "id": return "text";
+		case "text": return "text";
+		case "integer": return "integer";
+		case "real": return "double precision";
+		case "decimal": return De(e, "NUMERIC");
+		case "bigint": return "bigint";
+		case "boolean": return "boolean";
+		case "timestamp": return "timestamptz";
+		case "date": return "date";
+		case "json": return "jsonb";
+		case "bytes": return "bytea";
+		case "reference": return e.referenceStorage === "numeric" ? "bigint" : "text";
+		case "vector":
+		case "enum":
+		case "array": throw Error(`snapshotPgType: '${e.type}' must go through parameterisedSqlType`);
+		case "interval": return "interval";
+		case "raw": return e.rawDdl ?? "text";
+	}
+}, Ae = (e) => {
+	let t = N(e, "mariadb");
+	if (t !== void 0) return t;
+	switch (e.type) {
+		case "id": return "VARCHAR(64)";
+		case "text": return "LONGTEXT";
+		case "integer": return "INT";
+		case "real": return "DOUBLE";
+		case "decimal": return De(e, "DECIMAL");
+		case "bigint": return "BIGINT";
+		case "boolean": return "TINYINT(1)";
+		case "timestamp": return "DATETIME(6)";
+		case "date": return "DATE";
+		case "json": return "JSON";
+		case "bytes": return "LONGBLOB";
+		case "reference": return e.referenceStorage === "numeric" ? "BIGINT" : "VARCHAR(64)";
+		case "vector":
+		case "enum":
+		case "array": throw Error(`snapshotMysqlType: '${e.type}' must go through parameterisedSqlType`);
+		case "interval": return "BIGINT";
+		case "raw": return e.rawDdl ?? "LONGTEXT";
+	}
+}, F = (e) => `"${e}"`, I = (e) => `\`${e.replace(/`/g, "``")}\``, je = (e) => e === "mariadb" ? "IF NOT EXISTS " : "", L = (e, t, n = !0) => `ALTER TABLE ${t(e.table)} DROP COLUMN ${n ? "IF EXISTS " : ""}${t(e.column)};`, Me = (e, t = "mariadb") => `ALTER TABLE ${I(e.table)} DROP COLUMN ${t === "mariadb" ? "IF EXISTS " : ""}${I(e.column)}, ALGORITHM=COPY;`, R = (e, t) => `ALTER TABLE ${t(e.table)} RENAME COLUMN ${t(e.from)} TO ${t(e.to)};`, Ne = (e, t, n) => `ALTER TABLE ${n(e.table)} RENAME COLUMN ${n(e.column)} TO ${n(t)};`, Pe = (e, t, n) => e.hasDefault && e.defaultValue !== void 0 ? `ALTER TABLE ${t(e.table)} ALTER COLUMN ${t(e.column)} SET ${Ie(e, n)};` : `ALTER TABLE ${t(e.table)} ALTER COLUMN ${t(e.column)} DROP DEFAULT;`, Fe = (e, t) => {
+	let { defaultFactory: n, ...r } = e;
+	return T(e, t) !== T({
+		...r,
+		hasDefault: !1
+	}, t);
+}, Ie = (e, t) => {
+	let n = t(e.defaultValue);
+	if (n === null) throw Error(`migration applier: cannot render the declared default for '${e.table}.${e.column}' (${JSON.stringify(e.defaultValue)}). Emitting 'DEFAULT NULL' would apply cleanly and drop the default silently, so this fails instead. This is a framework bug — report the column type + default.`);
+	return n;
+}, z = (e, t, n) => e.find((e) => e.tableName === t)?.fields[n], B = (e, t, n) => {
+	let r = z(e, t, n);
+	return r ? E(n, r) : void 0;
+}, Le = (e, t, n, r) => {
+	let i = n ?? e.nullable, a = S(e, "mariadb");
+	return [
+		I(t),
+		T(e, "mariadb"),
+		i ? null : "NOT NULL",
+		a,
+		r === void 0 ? null : `CHECK (${r})`
+	].filter(Boolean).join(" ");
+}, Re = /^json_valid\(`[^`]+`\)$/i, ze = (e, t) => A(e).pipe(M.flatMap((n) => n === "mariadb" ? e`
+        SELECT constraint_name AS n, check_clause AS c
+        FROM information_schema.check_constraints
+        WHERE constraint_schema = DATABASE() AND table_name = ${t} AND level = 'Column'`.pipe(M.map((e) => new Map(e.map((e) => [String(e.n ?? ""), String(e.c ?? "")]).filter(([e, t]) => e !== "" && t !== "" && !Re.test(t.trim()))))) : M.succeed(/* @__PURE__ */ new Map()))), V = (e, t, n, r, i) => M.map(ze(e, t), (e) => `ALTER TABLE ${I(t)} MODIFY COLUMN ${Le(n, r, i, e.get(r))};`), Be = (e, t) => e == null ? null : Array.isArray(e) ? Ve(e, t, "mariadb") : e === "now" ? "DEFAULT CURRENT_TIMESTAMP(6)" : typeof e == "boolean" ? `DEFAULT ${+!!e}` : typeof e == "number" ? `DEFAULT ${e}` : typeof e == "string" ? /[()]|^'/.test(e) ? `DEFAULT ${e}` : `DEFAULT '${e.replace(/'/g, "''")}'` : typeof e == "object" ? C(e, "mariadb") : null, Ve = (e, t, n) => x(e, t ?? { type: "json" }, n), He = (e, t) => e == null ? null : Array.isArray(e) ? Ve(e, t, "postgres") : e === "now" ? "DEFAULT now()" : typeof e == "boolean" || typeof e == "number" ? `DEFAULT ${e}` : typeof e == "string" ? /[()]|::|^'/.test(e) ? `DEFAULT ${e}` : `DEFAULT '${e.replace(/'/g, "''")}'` : typeof e == "object" ? C(e, "postgres") : null, H = (e, t) => {
+	if (!e.generatedAs) return null;
+	let { expr: n, stored: r } = e.generatedAs;
+	return t === "postgres" ? `GENERATED ALWAYS AS (${n}) STORED` : t === "mssql" ? `AS (${n})${r ? " PERSISTED" : ""}` : `GENERATED ALWAYS AS (${n}) ${r ? "STORED" : "VIRTUAL"}`;
+}, Ue = (e, t = !1) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return w(e.name, "postgres");
+	let n = H(e, "postgres");
+	if (n) return `${F(e.name)} ${P(e)} ${n}`;
+	let r = [F(e.name), P(e)];
+	if (e.type === "id" && !t && r.push("PRIMARY KEY"), e.nullable || r.push("NOT NULL"), e.unique && e.type !== "id" && r.push("UNIQUE"), e.hasDefault) {
+		let t = He(e.defaultValue, e);
+		t && r.push(t);
+	}
+	return e.references && (r.push(`REFERENCES ${F(e.references.table)} (${F(e.references.column)})`), e.references.onDelete && r.push(`ON DELETE ${{
+		cascade: "CASCADE",
+		restrict: "RESTRICT",
+		setNull: "SET NULL",
+		noAction: "NO ACTION"
+	}[e.references.onDelete]}`)), r.join(" ");
+}, U = (e) => (e.primaryKey?.length ?? 0) > 0, W = (e, t) => e.primaryKey && e.primaryKey.length > 0 ? `,\n  PRIMARY KEY (${e.primaryKey.map(t).join(", ")})` : "", We = (e) => {
+	let t = e.columns.map((t) => `  ${Ue(t, U(e))}`).join(",\n"), n = [`CREATE TABLE IF NOT EXISTS ${F(e.table)} (\n${t}${W(e, F)}\n)`];
+	for (let t of e.indexes) t.name !== `${e.table}_pkey` && n.push(gt({
+		kind: "add-index",
+		table: e.table,
+		index: t
+	}, !1));
+	return n;
+}, Ge = 191, Ke = (e) => {
+	let t = Ae(e).toUpperCase();
+	return t.endsWith("TEXT") || t.endsWith("BLOB");
+}, qe = (e) => e.charset === void 0 ? Ae(e) : `${Ae(e)} CHARACTER SET ${e.charset}`, Je = (e, t = !1) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return w(e.name, "mariadb");
+	let n = qe(e), r = H(e, "mariadb");
+	if (r) return `${I(e.name)} ${n} ${r}`;
+	let i = [I(e.name), n];
+	if (e.type === "id" && !t && i.push("PRIMARY KEY"), e.nullable || i.push("NOT NULL"), e.unique && e.type !== "id" && !Ke(e) && i.push("UNIQUE"), e.hasDefault) {
+		let t = Be(e.defaultValue, e);
+		t && i.push(t);
+	}
+	return i.join(" ");
+}, Ye = (e) => e.columns.flatMap((t) => {
+	if (!t.references) return [];
+	let n = t.references.onDelete ? ` ON DELETE ${{
+		cascade: "CASCADE",
+		restrict: "RESTRICT",
+		setNull: "SET NULL",
+		noAction: "NO ACTION"
+	}[t.references.onDelete]}` : "";
+	return [`  CONSTRAINT ${I(`${e.table}_${t.name}_fkey`)} FOREIGN KEY (${I(t.name)}) REFERENCES ${I(t.references.table)} (${I(t.references.column)})${n}`];
+}), Xe = (e) => {
+	let t = e.find((e) => e.charset !== void 0)?.charset;
+	return t === void 0 ? "" : ` DEFAULT CHARACTER SET ${t}`;
+}, Ze = (e, t, n = /* @__PURE__ */ new Map()) => {
+	let r = e.foreignKeys.map((e) => `ALTER TABLE ${I(e.table)} DROP FOREIGN KEY ${I(e.name)}`), i = e.columns.map((r) => {
+		let i = z(t, e.table, r), a = B(t, e.table, r);
+		if (i === void 0 || a === void 0) throw Error(`convert-charset: no declared column '${e.table}.${r}' to render MODIFY COLUMN from; it was not in ctx.declared.`);
+		let o = H(a, "mariadb"), s = `${I(r)} ${T(i, "mariadb")} CHARACTER SET ${e.charset}`, c = n.get(r), l = c === void 0 ? null : `CHECK (${c})`;
+		if (o) return `MODIFY COLUMN ${[
+			s,
+			o,
+			l
+		].filter(Boolean).join(" ")}`;
+		let u = S(i, "mariadb");
+		return `MODIFY COLUMN ${[
+			s,
+			i.nullable ? null : "NOT NULL",
+			u,
+			l
+		].filter(Boolean).join(" ")}`;
+	});
+	return {
+		drops: r,
+		rewrite: `ALTER TABLE ${I(e.table)} ${[...i, `DEFAULT CHARACTER SET ${e.charset}`].join(", ")}`,
+		restores: e.foreignKeys.filter((e) => e.restore === "here").map((e) => `ALTER TABLE ${I(e.table)} ADD CONSTRAINT ${I(e.name)} FOREIGN KEY (${I(e.column)}) REFERENCES ${I(e.targetTable)} (${I(e.targetColumn)})` + (e.onDelete ? ` ON DELETE ${$e[e.onDelete]}` : "") + (e.onUpdate && e.onUpdate !== "noAction" ? ` ON UPDATE ${$e[e.onUpdate]}` : ""))
+	};
+}, Qe = (e, t = "mariadb") => {
+	for (let n of e.indexes) vt(n, t);
+	let n = new Map(e.columns.map((e) => [e.name, e])), r = (e) => {
+		let t = pt(n.get(e));
+		return t === void 0 ? I(e) : `${I(e)}(${t})`;
+	}, i = e.columns.map((t) => `  ${Je(t, U(e))}`).join(",\n"), a = Ye(e), o = a.length > 0 ? `${i},\n${a.join(",\n")}` : i, s = [`CREATE TABLE IF NOT EXISTS ${I(e.table)} (\n${o}${W(e, r)}\n)${Xe(e.columns)}`];
+	for (let n of e.columns) n.unique && n.type !== "id" && Ke(n) && s.push(`CREATE UNIQUE INDEX ${je(t)}${I(`${e.table}_${n.name}_key`)} ON ${I(e.table)} (${r(n.name)})`);
+	for (let n of e.indexes) n.name !== `${e.table}_pkey` && s.push(`CREATE ${n.unique ? "UNIQUE " : ""}INDEX ${je(t)}${I(n.name)} ON ${I(e.table)} (${n.columns.map(r).join(", ")})`);
+	return s;
+}, $e = {
+	cascade: "CASCADE",
+	restrict: "RESTRICT",
+	setNull: "SET NULL",
+	noAction: "NO ACTION"
+}, et = {
+	cascade: "CASCADE",
+	restrict: "NO ACTION",
+	setNull: "SET NULL",
+	noAction: "NO ACTION"
+}, tt = (e) => {
+	let t = N(e, "sqlite");
+	if (t !== void 0) return t;
+	switch (e.type) {
+		case "integer":
+		case "boolean": return "INTEGER";
+		case "reference": return e.referenceStorage === "numeric" ? "INTEGER" : "TEXT";
+		case "bigint": return "INTEGER";
+		case "real": return "REAL";
+		case "decimal": return "NUMERIC";
+		case "bytes": return "BLOB";
+		default: return "TEXT";
+	}
+}, G = (e, t) => e == null ? null : e === "now" ? `DEFAULT ${t}` : typeof e == "boolean" ? `DEFAULT ${+!!e}` : typeof e == "number" ? `DEFAULT ${e}` : typeof e == "string" ? /[()]|^'/.test(e) ? `DEFAULT ${e}` : `DEFAULT '${e.replace(/'/g, "''")}'` : typeof e == "object" ? C(e, "sqlite") : null, nt = (e, t = !1) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return w(e.name, "sqlite");
+	let n = H(e, "sqlite"), a = i(e), o = a === void 0 ? void 0 : `CHECK (${r(F(e.name), a)})`;
+	if (n) return `${F(e.name)} ${tt(e)} ${n}${o ? ` ${o}` : ""}`;
+	let s = [F(e.name), tt(e)];
+	if (o && s.push(o), e.type === "id" && !t && s.push("PRIMARY KEY"), e.nullable || s.push("NOT NULL"), e.unique && e.type !== "id" && s.push("UNIQUE"), e.hasDefault) {
+		let t = G(e.defaultValue, "CURRENT_TIMESTAMP");
+		t && s.push(t);
+	}
+	if (e.references && (s.push(`REFERENCES ${F(e.references.table)} (${F(e.references.column)})`), e.references.onDelete && s.push(`ON DELETE ${$e[e.references.onDelete]}`)), e.oneOf && e.oneOf.length > 0) {
+		let t = e.oneOf.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		s.push(`CHECK (${F(e.name)} IN (${t}))`);
+	}
+	return s.join(" ");
+}, rt = (e) => {
+	let t = e.columns.map((t) => `  ${nt(t, U(e))}`).join(",\n"), n = [`CREATE TABLE IF NOT EXISTS ${F(e.table)} (\n${t}${W(e, F)}\n)`];
+	for (let t of e.indexes) t.name !== `${e.table}_pkey` && n.push(`CREATE ${t.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${F(t.name)} ON ${F(e.table)} (${t.columns.map(F).join(", ")})${q(t)}`);
+	return n;
+}, it = (e, t) => {
+	let n = t.find((t) => t.tableName === e);
+	return n ? at(ue([n], "sqlite").tables[0]) : [];
+}, at = (e) => {
+	let t = e.name, n = `${t}__voltro_rebuild_${Te().replaceAll("-", "")}`, r = e.columns.map((e) => F(e.name)).join(", "), i = [
+		...rt({
+			kind: "create-table",
+			table: n,
+			columns: e.columns,
+			indexes: [],
+			...e.primaryKey ? { primaryKey: e.primaryKey } : {}
+		}).map((e) => e.replace(/^CREATE TABLE IF NOT EXISTS /, "CREATE TABLE ")),
+		`INSERT INTO ${F(n)} (${r}) SELECT ${r} FROM ${F(t)}`,
+		`DROP TABLE ${F(t)}`,
+		`ALTER TABLE ${F(n)} RENAME TO ${F(t)}`
+	];
+	for (let n of e.indexes) n.name !== `${t}_pkey` && i.push(`CREATE ${n.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${F(n.name)} ON ${F(t)} (${n.columns.map(F).join(", ")})${q(n)}`);
+	return i;
+}, ot = (e, t, n, r) => {
+	let i = r ?? e.nullable;
+	return `ALTER TABLE ${K(n)} ALTER COLUMN ${K(t)} ${T(e, "mssql")} ${i ? "NULL" : "NOT NULL"};`;
+}, st = (e, t) => {
+	let n = `DECLARE @dc sysname; SELECT @dc = dc.name FROM sys.default_constraints dc JOIN sys.columns col ON col.object_id = dc.parent_object_id AND col.column_id = dc.parent_column_id WHERE dc.parent_object_id = OBJECT_ID(N'${e.table.replace(/'/g, "''")}') AND col.name = N'${e.column.replace(/'/g, "''")}'; IF @dc IS NOT NULL EXEC(N'ALTER TABLE ${K(e.table)} DROP CONSTRAINT [' + @dc + ']');` + (t ? ` ${t}` : "");
+	if (!e.hasDefault) return n;
+	let r = G(e.defaultValue, "SYSUTCDATETIME()");
+	if (!r) return n;
+	let i = r.replace(/^DEFAULT\s+/i, "");
+	return `${n} ALTER TABLE ${K(e.table)} ADD DEFAULT ${i} FOR ${K(e.column)};`;
+}, K = (e) => `[${e.replace(/]/g, "]]")}]`, ct = (e) => {
+	let t = N(e, "mssql");
+	if (t !== void 0) return t;
+	switch (e.type) {
+		case "id": return "NVARCHAR(64)";
+		case "reference": return e.referenceStorage === "numeric" ? "BIGINT" : "NVARCHAR(64)";
+		case "integer": return "INT";
+		case "real": return "FLOAT";
+		case "decimal": return De(e, "DECIMAL");
+		case "bigint": return "BIGINT";
+		case "boolean": return "BIT";
+		case "timestamp": return "DATETIME2(6)";
+		case "date": return "DATE";
+		case "bytes": return "VARBINARY(MAX)";
+		default: return "NVARCHAR(MAX)";
+	}
+}, lt = (e, t, n = !1) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return w(e.name, "mssql");
+	let r = e.type === "text" && t?.has(e.name) ? `NVARCHAR(${Math.min(e.maxLength ?? 450, 450)})` : ct(e), i = H(e, "mssql");
+	if (i) return `${K(e.name)} ${i}`;
+	let a = [K(e.name), r];
+	if (e.type === "json" && a.push(`CHECK ${b(K(e.name))}`), e.type === "array" && a.push(`CHECK (${K(e.name)} IS NULL OR ISJSON(${K(e.name)}) = 1)`), e.type === "id" && !n && a.push("PRIMARY KEY"), e.nullable || a.push("NOT NULL"), e.unique && e.type !== "id" && a.push("UNIQUE"), e.hasDefault) {
+		let t = G(e.defaultValue, "SYSUTCDATETIME()");
+		t && a.push(t);
+	}
+	return e.references && (a.push(`REFERENCES ${K(e.references.table)} (${K(e.references.column)})`), e.references.onDelete && a.push(`ON DELETE ${et[e.references.onDelete]}`)), a.join(" ");
+}, ut = (e) => {
+	let t = (e) => e.replace(/'/g, "''"), n = /* @__PURE__ */ new Set([...e.indexes.flatMap((e) => e.columns), ...e.columns.filter((e) => e.unique).map((e) => e.name)]), r = e.columns.map((t) => `  ${lt(t, n, U(e))}`).join(",\n"), i = `CREATE TABLE ${K(e.table)} (\n${r}${W(e, K)}\n)`, a = [`IF OBJECT_ID(N'${t(e.table)}', N'U') IS NULL EXEC(N'${t(i)}')`];
+	for (let n of e.indexes) {
+		if (n.name === `${e.table}_pkey`) continue;
+		let r = `CREATE ${n.unique ? "UNIQUE " : ""}INDEX ${K(n.name)} ON ${K(e.table)} (${n.columns.map(K).join(", ")})${q(n)}`;
+		a.push(`IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = N'${t(n.name)}' AND object_id = OBJECT_ID(N'${t(e.table)}')) EXEC(N'${t(r)}')`);
+	}
+	return a;
+}, dt = (e, t) => `DROP TABLE IF EXISTS ${t(e.table)};`, ft = (e, t, n) => `ALTER TABLE ${n(e.table)} RENAME TO ${n(t)};`, pt = (e) => {
+	if (e === void 0 || !Ke(e)) return;
+	let t = typeof e.maxLength == "number" && e.maxLength > 0 ? e.maxLength : void 0;
+	return t === void 0 ? Ge : Math.min(Ge, t);
+}, mt = (e, t, n) => {
+	let r = pt(B(e, t, n));
+	return r === void 0 ? I(n) : `${I(n)}(${r})`;
+}, ht = (e) => e.startsWith("(") ? e : F(e), q = (e) => e.where === void 0 ? "" : ` WHERE ${e.where}`, gt = (e, t) => {
+	let n = p(e.index.kind, e.index.kindOptions), r = e.index.columns.map(ht);
+	if (n.opclass !== void 0) {
+		if (r.length !== 1) throw Error("HNSW index requires exactly one column");
+		r[0] = `${r[0]} ${n.opclass}`;
+	}
+	return `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX ${t ? "CONCURRENTLY " : ""}IF NOT EXISTS ${F(e.index.name)} ON ${F(e.table)}${n.using} (${r.join(", ")})${n.withSuffix}${q(e.index)};`;
+}, _t = (e, t, n = "mariadb") => (vt(e.index, n), `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX ${je(n)}${I(e.index.name)} ON ${I(e.table)} (${e.index.columns.map((n) => mt(t, e.table, n)).join(", ")});`), vt = (e, t) => {
+	if (e.where !== void 0) throw Error(`Partial index '${e.name}' is not supported by ${t}; uniqueActive must be lowered before applying the plan.`);
+}, yt = (e) => `DROP INDEX IF EXISTS ${F(e.index)};`, bt = (e) => `DROP INDEX ${I(e.index)} ON ${I(e.table)};`, xt = (e) => `DROP INDEX IF EXISTS ${K(e.index)} ON ${K(e.table)};`, St = (e, t) => `ALTER TABLE ${t(e.from)} RENAME TO ${t(e.to)};`, Ct = (e) => {
+	let t = (e) => e.replace(/'/g, "''");
+	return `EXEC sp_rename N'${t(e.from)}', N'${t(e.to)}';`;
+}, wt = (e) => `ALTER INDEX ${F(e.from)} RENAME TO ${F(e.to)};`, Tt = (e) => `ALTER TABLE ${I(e.table)} RENAME INDEX ${I(e.from)} TO ${I(e.to)};`, Et = (e) => {
+	let t = (e) => e.replace(/'/g, "''");
+	return `EXEC sp_rename N'${t(e.table)}.${t(e.from)}', N'${t(e.to)}', N'INDEX';`;
+}, Dt = (e) => {
+	let t = (e) => e.replace(/'/g, "''"), n = `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX ${K(e.index.name)} ON ${K(e.table)} (${e.index.columns.map(K).join(", ")})${q(e.index)}`;
+	return `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = N'${t(e.index.name)}' AND object_id = OBJECT_ID(N'${t(e.table)}')) EXEC(N'${t(n)}');`;
+}, Ot = (e, t, n) => {
+	let r = n.find((t) => t.tableName === e);
+	if (!r) return [];
+	let i = [];
+	for (let n of t) {
+		let t = r.fields[n];
+		if (t && t.type === "text" && !t.generatedAs) {
+			let r = Math.min(t.maxLength ?? 450, 450);
+			i.push(`ALTER TABLE ${K(e)} ALTER COLUMN ${K(n)} NVARCHAR(${r}) ${t.nullable ? "NULL" : "NOT NULL"};`);
+		}
+	}
+	return i;
+}, kt = (e) => `ALTER TABLE ${F(e.table)} ADD CONSTRAINT ${F(`${e.table}_${e.column}_key`)} UNIQUE (${F(e.column)});`, At = (e, t) => `ALTER TABLE ${I(e.table)} ADD CONSTRAINT ${I(`${e.table}_${e.column}_key`)} UNIQUE (${mt(t, e.table, e.column)});`, jt = (e) => {
+	let t = e.fields.map((e) => F(e)).join(", ");
+	return `ALTER TABLE ${F(e.table)} ADD CONSTRAINT ${F(e.name)} UNIQUE (${t});`;
+}, Mt = (e, t) => {
+	let n = e.fields.map((n) => mt(t, e.table, n)).join(", ");
+	return `ALTER TABLE ${I(e.table)} ADD CONSTRAINT ${I(e.name)} UNIQUE (${n});`;
+}, Nt = (e) => `ALTER TABLE ${F(e.table)} DROP CONSTRAINT IF EXISTS ${F(e.name)};`, Pt = (e) => [Nt(e), `DROP INDEX IF EXISTS ${F(e.name)};`], Ft = (e) => e.name === `${e.table}_pkey` ? `ALTER TABLE ${I(e.table)} DROP PRIMARY KEY;` : `ALTER TABLE ${I(e.table)} DROP INDEX ${I(e.name)};`, It = (e) => `ALTER TABLE ${F(e.table)} DROP CONSTRAINT IF EXISTS ${F(`${e.table}_${e.column}_key`)};`, Lt = (e) => `ALTER TABLE ${I(e.table)} DROP INDEX ${I(`${e.table}_${e.column}_key`)};`, Rt = (e, t, n = $e) => {
+	let r = [], i = t(e.table), a = t(e.column), o = t(e.targetTable), s = t(e.targetColumn);
+	if (e.orphanPolicy) {
+		let t = `${a} IS NOT NULL AND ${a} NOT IN (SELECT ${s} FROM ${o})`;
+		r.push(e.orphanPolicy === "delete" ? `DELETE FROM ${i} WHERE ${t};` : `UPDATE ${i} SET ${a} = NULL WHERE ${t};`);
+	}
+	let c = [
+		`ALTER TABLE ${i}`,
+		`ADD CONSTRAINT ${t(`${e.table}_${e.column}_fkey`)}`,
+		`FOREIGN KEY (${a})`,
+		`REFERENCES ${o} (${s})`
+	];
+	return e.onDelete && c.push(`ON DELETE ${n[e.onDelete]}`), r.push(c.join(" ") + ";"), r;
+}, zt = (e) => e.name ?? `${e.table}_${e.column}_fkey`, Bt = (e) => `ALTER TABLE ${F(e.table)} DROP CONSTRAINT IF EXISTS ${F(zt(e))};`, Vt = (e) => `ALTER TABLE ${I(e.table)} DROP FOREIGN KEY ${I(zt(e))};`, Ht = (e, t) => {
+	let n = e.values.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+	return `ALTER TABLE ${t(e.table)} ADD CONSTRAINT ${t(`${e.table}_${e.column}_check`)} CHECK (${t(e.column)} IN (${n}));`;
+}, Ut = (e) => `ALTER TABLE ${F(e.table)} DROP CONSTRAINT IF EXISTS ${F(`${e.table}_${e.column}_check`)};`, Wt = (e, t) => M.gen(function* () {
+	let n = yield* e`
+      SELECT cc.constraint_name AS n, cc.check_clause AS c
+      FROM information_schema.check_constraints cc
+      WHERE cc.constraint_schema = DATABASE() AND cc.table_name = ${t.table}`.pipe(M.catch(() => e`
+        SELECT cc.constraint_name AS n, cc.check_clause AS c
+        FROM information_schema.check_constraints cc
+        JOIN information_schema.table_constraints tc
+          ON tc.constraint_schema = cc.constraint_schema
+         AND tc.constraint_name   = cc.constraint_name
+        WHERE tc.table_schema = DATABASE() AND tc.table_name = ${t.table}`), M.orElseSucceed(() => []));
+	for (let e of n) {
+		let n = String(e.n ?? "");
+		if (n !== "" && D(String(e.c ?? ""))?.column === t.column) return n;
+	}
+}), Gt = (e, t, n) => M.gen(function* () {
+	let r = yield* Wt(e, t);
+	r !== void 0 && (yield* J(e, `ALTER TABLE ${I(t.table)} DROP CONSTRAINT ${I(r)};`, t.kind, [ge]));
+	let i = yield* Wt(e, t);
+	if (i === void 0) return;
+	let a = z(n, t.table, t.column);
+	if (!a) return yield* M.die(/* @__PURE__ */ Error(`applier: cannot drop the CHECK on '${t.table}.${t.column}' — it is column-level (catalog name '${i}'), which this family removes only by redefining the column, and the declared column is not available to redefine it from.`));
+	yield* J(e, `ALTER TABLE ${I(t.table)} MODIFY COLUMN ${Le(a, t.column)};`, t.kind);
+}), Kt = (e, t, n, r) => {
+	let i = e.column, a = r === "mariadb", o = a ? I : r === "mssql" ? K : F, s = a ? qe(i) : r === "mssql" ? ct(i) : r === "sqlite" ? tt(i) : P(i), c = r === "mssql" ? "ADD" : "ADD COLUMN", l = r === "mssql" ? i.type === "json" ? ` CHECK ${b(o(i.name))}` : i.type === "array" ? ` CHECK (${o(i.name)} IS NULL OR ISJSON(${o(i.name)}) = 1)` : "" : "", u = (e) => a ? Be(e, i) : r === "mssql" ? G(e, "SYSUTCDATETIME()") : r === "sqlite" ? G(e, "CURRENT_TIMESTAMP") : He(e, i), d = H(i, r);
+	if (d) {
+		let t = r === "mssql" ? `${o(i.name)} ${d}` : `${o(i.name)} ${s} ${d}`;
+		return {
+			pre: [`ALTER TABLE ${o(e.table)} ${c} ${t};`],
+			post: []
+		};
+	}
+	if (i.type === "id" && i.idScheme?.kind === "numeric" && (r === "postgres" || a)) return {
+		pre: [`ALTER TABLE ${o(e.table)} ${c} ${w(i.name, r)};`],
+		post: []
+	};
+	if (t.classification === "safe") {
+		let t = [`ALTER TABLE ${o(e.table)} ${c} ${o(i.name)} ${s}`];
+		return i.unique && t.push("UNIQUE"), {
+			pre: [`${t.join(" ")}${l};`],
+			post: []
+		};
+	}
+	if (t.classification === "needs-default") {
+		let t = u(i.defaultValue);
+		if (t === null) throw Error(`migration applier: cannot render the declared default for '${e.table}.${i.name}' (${JSON.stringify(i.defaultValue)}) while adding it NOT NULL to a populated table. This is a framework bug — report the column type + default.`);
+		return {
+			pre: [`ALTER TABLE ${o(e.table)} ${c} ${o(i.name)} ${s} NOT NULL ${t}${l};`],
+			post: [],
+			...i.unique && i.type !== "id" ? { uniquePending: !0 } : {}
+		};
+	}
+	let f = n(e.table, i.name), p = a ? `ALTER TABLE ${o(e.table)} MODIFY COLUMN ${o(i.name)} ${s} NOT NULL;` : r === "mssql" ? `ALTER TABLE ${o(e.table)} ALTER COLUMN ${o(i.name)} ${s} NOT NULL;` : r === "sqlite" ? null : `ALTER TABLE ${o(e.table)} ALTER COLUMN ${o(i.name)} SET NOT NULL;`, m = {
+		pre: [`ALTER TABLE ${o(e.table)} ${c} ${o(i.name)} ${s}${l};`],
+		post: p ? [p] : []
+	};
+	return i.unique && i.type !== "id" && (m.uniquePending = !0), f?.sql && (m.backfillKind = "sql", m.backfillSql = f.sql), f?.js && (m.backfillKind = "js", m.backfillJs = f.js), f?.batchSize !== void 0 && (m.batchSize = f.batchSize), f?.sleepMs !== void 0 && (m.sleepMs = f.sleepMs), m;
+}, qt = /* @__PURE__ */ new Set([
+	"drop-index",
+	"drop-check",
+	"drop-unique",
+	"drop-unique-composite",
+	"drop-foreign-key",
+	"drop-column",
+	"drop-table"
+]), Jt = (e) => {
+	let t = new Map(e.map((e) => [e.tableName, e]));
+	return (e, n) => {
+		let r = t.get(e);
+		if (!r) return;
+		let i = r.fields[n];
+		if (!i || !i.backfill) return;
+		let a = i.backfill, o = {
+			...a.batchSize === void 0 ? {} : { batchSize: a.batchSize },
+			...a.sleepMs === void 0 ? {} : { sleepMs: a.sleepMs }
+		};
+		if (a.kind === "sql" && a.sql) return {
+			sql: a.sql,
+			...o
+		};
+		if (a.kind === "js" && a.fn) return {
+			js: a.fn,
+			...o
+		};
+	};
+}, J = (e, t, n, r = []) => e.unsafe(t).pipe(M.catchIf((e) => be(e, r), () => M.void), M.tapError((e) => M.sync(() => {
+	process.stderr.write(m(`applier: statement failed (op=${n})`, t, e, 400));
+})), M.mapError((e) => {
+	let r = m(`applier: statement failed (op=${n})`, t, e, 400).trim();
+	return s(r, e);
+}), M.map(() => void 0)), Y = (e, t, n, r) => Yt(e, t, it(t, n), r), Yt = (e, t, n, r) => le(e, n).pipe(M.mapError((e) => s(`applier: atomic SQLite rebuild failed (op=${r}, table=${t}): ${e.message}`, e))), Xt = (e, t) => M.gen(function* () {
+	let r = (yield* e`
+      SELECT ck.name, ck.definition, ck.is_disabled AS disabled,
+        ck.is_not_trusted AS untrusted, ck.is_not_for_replication AS notForReplication
+      FROM sys.check_constraints ck
+      WHERE ck.parent_object_id = OBJECT_ID(${t.table}) AND EXISTS (
+        SELECT 1 FROM sys.sql_expression_dependencies dep
+        JOIN sys.columns col ON col.object_id = dep.referenced_id AND col.column_id = dep.referenced_minor_id
+        WHERE dep.referencing_id = ck.object_id AND col.object_id = ck.parent_object_id AND col.name = ${t.from}
+      ) ORDER BY ck.name
+    `).map((e) => ({
+		...e,
+		definition: Se(e.definition, t.from, t.to)
+	})), i = (e) => n(e, "mssql"), a = (e) => e.replace(/'/g, "''");
+	return yield* X(e, [
+		...r.map((e) => `ALTER TABLE ${i(t.table)} DROP CONSTRAINT ${i(e.name)}`),
+		`EXEC sp_rename N'${a(`${i(t.table)}.${i(t.from)}`)}', N'${a(t.to)}', 'COLUMN';`,
+		...r.flatMap((e) => [`ALTER TABLE ${i(t.table)} WITH ${e.untrusted ? "NOCHECK" : "CHECK"} ADD CONSTRAINT ${i(e.name)} CHECK ${e.notForReplication ? "NOT FOR REPLICATION " : ""}${e.definition}`, ...e.disabled ? [`ALTER TABLE ${i(t.table)} NOCHECK CONSTRAINT ${i(e.name)}`] : []])
+	], t.kind);
+}), Zt = (e, t, n) => e == null ? e : t.type === "json" ? JSON.stringify(e) : (t.type === "array" || t.type === "vector") && n !== "postgres" ? typeof e == "string" ? e : JSON.stringify(e) : e, X = (e, t, n) => M.forEach(t, (t) => J(e, t, n), { discard: !0 }), Z = (e, t, r, i) => e.unsafe(`SELECT ${i === void 0 ? "*" : n(i, t)} FROM ${n(r, t)} WHERE 1=0`).pipe(M.as(!0), M.catch(() => M.succeed(!1))), Qt = (e, t, n) => Q(e, t, re, h, n), $t = (e, t, n) => Q(e, t, c, "_voltro_migration_plans", n), en = (e, t, n) => Q(e, t, u, "_voltro_schema_owner", n), tn = (e, t, n) => Q(e, t, l, "_voltro_plugin_migrations", n), nn = (e, t, n) => Q(e, t, fe, de, n), rn = (e, t, n) => Q(e, t, f, d, n), Q = (t, n, r, i, a) => M.gen(function* () {
+	let o = ue([r], n, a !== void 0 && e(n) ? { charset: a } : {}).tables[0];
+	if (!o) return yield* M.die(/* @__PURE__ */ Error(`migration applier: the ${i} table descriptor produced no snapshot. This is a framework bug.`));
+	let s = {
+		kind: "create-table",
+		table: i,
+		columns: o.columns,
+		indexes: []
+	}, c = yield* t.onDialectOrElse({
+		mysql: () => A(t).pipe(M.map((e) => Qe(s, e))),
+		mssql: () => M.succeed(ut(s)),
+		sqlite: () => M.succeed(rt(s)),
+		orElse: () => M.succeed(We(s))
+	});
+	yield* M.forEach(c, (e) => J(t, e, "resume-ledger-bootstrap"), { discard: !0 });
+}), an = (e) => e`
+    SELECT ${e("runId")}, ${e("planFingerprint")}, ${e("opIndex")},
+           ${e("status")}, ${e("payload")}
+    FROM ${e(h)}
+  `, on = (e) => O(e, h).pipe(M.flatMap((t) => t ? an(e).pipe(M.map((e) => e.length > 0)) : M.succeed(!1))), sn = (e, t, n, r) => M.gen(function* () {
+	let i = yield* j(e, (/* @__PURE__ */ new Date()).toISOString());
+	yield* M.forEach(r, ({ index: r, planned: a }) => e`
+        INSERT INTO ${e(h)}
+          (${e("id")}, ${e("runId")}, ${e("planFingerprint")}, ${e("opIndex")},
+           ${e("opKind")}, ${e("opTarget")}, ${e("status")}, ${e("payload")},
+           ${e("createdAt")})
+        VALUES
+          (${`mop_${t}_${r}`}, ${t}, ${n}, ${r},
+           ${a.op.kind}, ${ae(a.op)}, ${"pending"},
+           ${JSON.stringify(a)}, ${i})
+      `, { discard: !0 });
+}), $ = (e, t, n, r, i, a) => M.gen(function* () {
+	let o = yield* j(e, (/* @__PURE__ */ new Date()).toISOString());
+	r === "applied" ? yield* e`
+        UPDATE ${e(h)}
+        SET ${e("status")} = ${r}, ${e("appliedAt")} = ${o},
+            ${e("durationMs")} = ${i ?? null}
+        WHERE ${e("runId")} = ${t} AND ${e("opIndex")} = ${n}
+      ` : r === "started" && a !== void 0 && ["sqlite", "turso"].includes(_(e)) ? yield* e`
+        UPDATE ${e(h)}
+        SET ${e("status")} = ${r}, ${e("startedAt")} = ${o},
+            ${e("payload")} = ${JSON.stringify({
+		...a,
+		sqliteAtomicRebuild: !0
+	})}
+        WHERE ${e("runId")} = ${t} AND ${e("opIndex")} = ${n}
+      ` : yield* e`
+      UPDATE ${e(h)}
+      SET ${e("status")} = ${r}, ${e("startedAt")} = ${o}
+      WHERE ${e("runId")} = ${t} AND ${e("opIndex")} = ${n}
+    `;
+}), cn = (e, t, n, r) => M.gen(function* () {
+	let i = yield* j(e, (/* @__PURE__ */ new Date()).toISOString());
+	r.length > 0 && (yield* e`
+        UPDATE ${e(h)}
+        SET ${e("status")} = ${"applied"}, ${e("appliedAt")} = ${i}
+        WHERE ${e("runId")} = ${t} AND ${e("opIndex")} IN ${e.in(r)}
+      `), n.length > 0 && (yield* e`
+        UPDATE ${e(h)}
+        SET ${e("status")} = ${"pending"}
+        WHERE ${e("runId")} = ${t} AND ${e("opIndex")} IN ${e.in(n)}
+      `);
+}), ln = (e, t) => t === void 0 ? e`DELETE FROM ${e(h)}`.pipe(M.asVoid) : e`DELETE FROM ${e(h)} WHERE ${e("runId")} = ${t}`.pipe(M.asVoid), un = (e) => an(e).pipe(M.map((e) => e.filter((e) => e.status === "started" || e.status === "added" || e.status === "applied").map((e) => JSON.parse(e.payload))), M.catch(() => M.succeed([]))), dn = (e) => ln(e).pipe(M.catch(() => M.void)), fn = (e, t, r) => M.gen(function* () {
+	if (y(r.op, r.classification, t) !== "artefact-repair") return "clean";
+	let i = r.op, a = (e) => n(e, t);
+	if (t === "postgres" && i.kind === "add-index") {
+		let t = yield* e`
+        SELECT ns.nspname AS schema_name
+        FROM pg_index ix
+        JOIN pg_class idx ON idx.oid = ix.indexrelid
+        JOIN pg_namespace ns ON ns.oid = idx.relnamespace
+        WHERE ix.indrelid = to_regclass(${a(i.table)})
+          AND idx.relname = ${i.index.name}
+          AND NOT ix.indisvalid
+      `;
+		return t.length === 0 ? "clean" : (yield* J(e, `DROP INDEX CONCURRENTLY ${a(t[0].schema_name)}.${a(i.index.name)}`, "resume-repair"), "outstanding");
+	}
+	if (t === "sqlite" || t === "turso") {
+		if (!("table" in i)) return "clean";
+		let n = `${i.table}${ne}`;
+		return (yield* Z(e, t, n)) ? ((yield* Z(e, t, i.table)) ? yield* J(e, `DROP TABLE ${a(n)}`, "resume-repair") : yield* J(e, `ALTER TABLE ${a(n)} RENAME TO ${a(i.table)}`, "resume-repair"), yield* M.logWarning(`migration resume: reconciled an interrupted sqlite table rebuild on '${i.table}' — replaying the operation`).pipe(M.annotateLogs({ scope: "voltro:migrate" })), "outstanding") : "clean";
+	}
+	if (i.kind !== "alter-column-type") return "clean";
+	let o = `${i.column}${te}`, s = `${i.column}${g}`, c = yield* Z(e, t, i.table, i.column), l = yield* Z(e, t, i.table, o), u = yield* Z(e, t, i.table, s), d = (e) => M.logWarning(`migration resume: ${e}`).pipe(M.annotateLogs({ scope: "voltro:migrate" }));
+	return !l && !u ? "clean" : c && l && !u ? (yield* J(e, `ALTER TABLE ${a(i.table)} DROP COLUMN ${a(o)}`, "resume-repair"), yield* d(`dropped a half-populated shadow column '${i.table}.${o}' — replaying the type change`), "outstanding") : !c && l && u ? (yield* J(e, `ALTER TABLE ${a(i.table)} RENAME COLUMN ${a(o)} TO ${a(i.column)}`, "resume-repair"), yield* J(e, `ALTER TABLE ${a(i.table)} DROP COLUMN ${a(s)}`, "resume-repair"), yield* d(`completed an interrupted shadow swap on '${i.table}.${i.column}'`), "applied") : c && !l && u ? (yield* J(e, `ALTER TABLE ${a(i.table)} DROP COLUMN ${a(s)}`, "resume-repair"), yield* d(`dropped the leftover pre-swap column '${i.table}.${s}'`), "applied") : yield* M.die(/* @__PURE__ */ Error(`applyPlan: an interrupted online type change on '${i.table}.${i.column}' left a shadow-swap state this resume cannot classify (column=${c}, ${o}=${l}, ${s}=${u}).\nNothing was changed. Inspect those three columns and reconcile them by hand — the data is in whichever of them is populated — then re-run the migration.`));
+}), pn = (e, r, i, o = "fresh", c) => M.gen(function* () {
+	let l = process.hrtime.bigint(), u = Jt(i.declared), d = r.op, f = _(e);
+	switch (d.kind) {
+		case "create-table": {
+			let t = yield* e.onDialectOrElse({
+				mysql: () => A(e).pipe(M.map((e) => Qe(d, e))),
+				mssql: () => M.succeed(ut(d)),
+				sqlite: () => M.succeed(rt(d)),
+				orElse: () => M.succeed(We(d))
+			}), n = yield* e.onDialectOrElse({
+				mysql: () => M.succeed([ve]),
+				orElse: () => M.succeed([])
+			});
+			for (let r of t) yield* J(e, r, d.kind, n);
+			break;
+		}
+		case "drop-table": {
+			let t = me(r), n = t !== void 0 || process.env.VOLTRO_SOFT_DROP === "1", i = t ?? pe(r, (/* @__PURE__ */ new Date()).toISOString()).softDropSnapshot, a = (e) => n ? ft(d, i, e) : dt(d, e);
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, a(I), d.kind),
+				mssql: () => J(e, n ? Ct({
+					kind: "rename-table",
+					from: d.table,
+					to: i
+				}) : dt(d, F), d.kind),
+				orElse: () => J(e, a(F), d.kind)
+			});
+			break;
+		}
+		case "drop-column": {
+			let t = me(r), n = t !== void 0 || process.env.VOLTRO_SOFT_DROP === "1", i = t ?? pe(r, (/* @__PURE__ */ new Date()).toISOString()).softDropSnapshot;
+			yield* e.onDialectOrElse({
+				mysql: () => A(e).pipe(M.flatMap((t) => J(e, n ? Ne(d, i, I) : Me(d, t), d.kind, n ? [] : [he]))),
+				mssql: () => n ? Xt(e, {
+					kind: "rename-column",
+					table: d.table,
+					from: d.column,
+					to: i
+				}) : J(e, L(d, F), d.kind),
+				sqlite: () => J(e, n ? Ne(d, i, F) : L(d, F, !1), d.kind, n ? [] : [ye]),
+				orElse: () => J(e, n ? Ne(d, i, F) : L(d, F), d.kind)
+			});
+			break;
+		}
+		case "rename-column":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, R(d, I), d.kind),
+				mssql: () => Xt(e, d),
+				orElse: () => J(e, R(d, F), d.kind)
+			});
+			break;
+		case "add-index":
+			yield* e.onDialectOrElse({
+				sqlite: () => J(e, gt(d, !1), d.kind),
+				mysql: () => A(e).pipe(M.flatMap((t) => J(e, _t(d, i.declared, t), d.kind, [ve]))),
+				mssql: () => X(e, [...Ot(d.table, d.index.columns, i.declared), Dt(d)], d.kind),
+				orElse: () => J(e, gt(d, r.classification === "online-required"), d.kind)
+			});
+			break;
+		case "drop-index":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, bt(d), d.kind),
+				mssql: () => J(e, xt(d), d.kind),
+				orElse: () => J(e, yt(d), d.kind)
+			});
+			break;
+		case "rename-table":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, St(d, I), d.kind),
+				mssql: () => J(e, Ct(d), d.kind),
+				orElse: () => J(e, St(d, F), d.kind)
+			});
+			break;
+		case "rename-index":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Tt(d), d.kind),
+				mssql: () => J(e, Et(d), d.kind),
+				orElse: () => J(e, wt(d), d.kind)
+			});
+			break;
+		case "add-unique":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, At(d, i.declared), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				mssql: () => X(e, [...Ot(d.table, [d.column], i.declared), kt(d)], d.kind),
+				orElse: () => J(e, kt(d), d.kind)
+			});
+			break;
+		case "drop-unique":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Lt(d), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				orElse: () => J(e, It(d), d.kind)
+			});
+			break;
+		case "add-enum-value":
+			yield* e.onDialectOrElse({
+				pg: () => d.enumName === void 0 ? M.die(/* @__PURE__ */ Error(`add-enum-value on postgres needs the type name for ${d.table}.${d.column}; the plan carries none.`)) : J(e, `ALTER TYPE ${n(d.enumName, "postgres")} ADD VALUE IF NOT EXISTS '${d.value.replace(/'/g, "''")}'`, d.kind),
+				mysql: () => {
+					let t = z(i.declared, d.table, d.column);
+					return t === void 0 || t.enumValues === void 0 || t.enumValues.length === 0 ? M.die(/* @__PURE__ */ Error(`add-enum-value on the mysql family needs the declared column ${d.table}.${d.column} and its labels; the declaration carries none.`)) : M.flatMap(V(e, d.table, t, d.column), (t) => J(e, t, d.kind));
+				},
+				orElse: () => M.void
+			});
+			break;
+		case "add-unique-composite":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Mt(d, i.declared), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				mssql: () => X(e, [...Ot(d.table, d.fields, i.declared), jt(d)], d.kind),
+				orElse: () => J(e, jt(d), d.kind)
+			});
+			break;
+		case "drop-unique-composite":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Ft(d), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				mssql: () => J(e, Nt(d), d.kind),
+				orElse: () => X(e, Pt(d), d.kind)
+			});
+			break;
+		case "add-foreign-key":
+			yield* e.onDialectOrElse({
+				mysql: () => X(e, Rt(d, I), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				mssql: () => X(e, Rt(d, K, et), d.kind),
+				orElse: () => X(e, Rt(d, F), d.kind)
+			});
+			break;
+		case "add-column": {
+			let n = Kt(d, r, u, yield* e.onDialectOrElse({
+				mysql: () => M.succeed("mariadb"),
+				mssql: () => M.succeed("mssql"),
+				sqlite: () => M.succeed("sqlite"),
+				orElse: () => M.succeed("postgres")
+			}));
+			if (!(o === "resume" && (yield* Z(e, _(e), d.table, d.column.name)))) for (let t of n.pre) yield* J(e, t, d.kind);
+			let s = r.classification === "online-required" || n.batchSize !== void 0 || n.sleepMs !== void 0, p = M.gen(function* () {
+				if (n.backfillKind === "sql" && n.backfillSql) {
+					if (r.classification !== "online-required" && n.batchSize === void 0) yield* e`UPDATE ${e(d.table)} SET ${e(d.column.name)} = ${n.backfillSql}`;
+					else {
+						let t = n.batchSize ?? 5e3, r = n.sleepMs ?? 0, i, a = 0;
+						for (;;) {
+							let o = i === void 0 ? yield* e`SELECT ${e("id")} FROM ${e(d.table)} WHERE ${e(d.column.name)} IS NULL ORDER BY ${e("id")} ${k(e, t)}` : yield* e`SELECT ${e("id")} FROM ${e(d.table)} WHERE ${e(d.column.name)} IS NULL AND ${e("id")} > ${i} ORDER BY ${e("id")} ${k(e, t)}`;
+							if (o.length === 0) break;
+							let s = o.map((e) => e.id);
+							yield* e`UPDATE ${e(d.table)} SET ${e(d.column.name)} = ${n.backfillSql} WHERE ${e("id")} IN ${e.in(s)}`, a += o.length, yield* M.logInfo(`backfill ${d.table}.${d.column.name}: ${a} rows`).pipe(M.annotateLogs({
+								scope: "voltro:migrate",
+								mode: "sql-batched"
+							})), i = o[o.length - 1].id, r > 0 && (yield* M.sleep(`${r} millis`));
+						}
+					}
+				} else if (n.backfillKind === "js" && n.backfillJs) {
+					let t = n.batchSize ?? 1e3, r = n.sleepMs ?? 0, o = i.declared.find((e) => e.tableName === d.table), s, c = 0;
+					for (;;) {
+						let i = s === void 0 ? yield* e`SELECT * FROM ${e(d.table)} WHERE ${e(d.column.name)} IS NULL ORDER BY ${e("id")} ${k(e, t)}` : yield* e`SELECT * FROM ${e(d.table)} WHERE ${e(d.column.name)} IS NULL AND ${e("id")} > ${s} ORDER BY ${e("id")} ${k(e, t)}`;
+						if (i.length === 0) break;
+						let l = o === void 0 ? i : a(i, o, f);
+						for (let t of l) {
+							let r = yield* M.tryPromise({
+								try: () => Promise.resolve(n.backfillJs(t)),
+								catch: (e) => e
+							}).pipe(M.orDie);
+							yield* e`UPDATE ${e(d.table)} SET ${e(d.column.name)} = ${Zt(r, d.column, f)} WHERE ${e("id")} = ${t.id}`;
+						}
+						c += l.length, yield* M.logInfo(`backfill ${d.table}.${d.column.name}: ${c} rows processed`).pipe(M.annotateLogs({
+							scope: "voltro:migrate",
+							table: d.table,
+							column: d.column.name
+						})), s = l[l.length - 1].id, r > 0 && (yield* M.sleep(`${r} millis`));
+					}
+				}
+			}), m = M.gen(function* () {
+				for (let t of n.post) yield* J(e, t, d.kind);
+				if (t(f) && (n.uniquePending === !0 || n.backfillKind !== void 0 && !d.column.nullable)) yield* Y(e, d.table, i.declared, d.kind);
+				else if (n.uniquePending === !0) {
+					let t = {
+						kind: "add-unique",
+						table: d.table,
+						column: d.column.name
+					};
+					yield* e.onDialectOrElse({
+						mysql: () => J(e, At(t, i.declared), d.kind),
+						mssql: () => X(e, [...Ot(d.table, [d.column.name], i.declared), kt(t)], d.kind),
+						orElse: () => J(e, kt(t), d.kind)
+					});
+				}
+			});
+			if (c !== void 0 && n.backfillKind !== void 0 && !s) return c({
+				table: d.table,
+				op: d,
+				data: p,
+				after: m
+			}), {
+				op: d,
+				status: "applied",
+				deferred: !0,
+				durationMs: Number(process.hrtime.bigint() - l) / 1e6
+			};
+			yield* p, yield* m;
+			break;
+		}
+		case "alter-column-nullability":
+			yield* e.onDialectOrElse({
+				mysql: () => {
+					let t = z(i.declared, d.table, d.column);
+					return t ? M.flatMap(V(e, d.table, t, d.column, d.toNullable), (t) => J(e, t, d.kind)) : M.die(/* @__PURE__ */ Error(`alter-column-nullability on mariadb needs the declared column '${d.table}.${d.column}' (to render MODIFY COLUMN); it was not in ctx.declared.`));
+				},
+				mssql: () => {
+					let t = z(i.declared, d.table, d.column);
+					return t ? J(e, ot(t, d.column, d.table, d.toNullable), d.kind) : M.die(/* @__PURE__ */ Error(`alter-column-nullability on mssql needs the declared column '${d.table}.${d.column}'.`));
+				},
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				orElse: () => J(e, `ALTER TABLE ${F(d.table)} ALTER COLUMN ${F(d.column)} ${d.toNullable ? "DROP NOT NULL" : "SET NOT NULL"};`, d.kind)
+			});
+			break;
+		case "alter-column-default": {
+			let t = B(i.declared, d.table, d.column), n = z(i.declared, d.table, d.column), r = (e) => d.hasDefault && n !== void 0 && Fe(n, e) ? n : void 0;
+			yield* e.onDialectOrElse({
+				mysql: () => {
+					let n = r("mariadb");
+					return M.flatMap(n ? V(e, d.table, n, d.column) : M.succeed(Pe(d, I, (e) => Be(e, t))), (t) => J(e, t, d.kind));
+				},
+				mssql: () => {
+					let t = r("mssql");
+					return J(e, st(d, t ? ot(t, d.column, d.table) : void 0), d.kind);
+				},
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				orElse: () => J(e, Pe(d, F, (e) => He(e, t)), d.kind)
+			});
+			break;
+		}
+		case "alter-column-type": {
+			let t = P(B(i.declared, d.table, d.column) ?? { type: d.to }), n = d.using ? ` USING ${d.using}` : "";
+			if (r.classification !== "online-required") {
+				yield* e.onDialectOrElse({
+					mysql: () => {
+						let t = z(i.declared, d.table, d.column);
+						return t ? M.flatMap(V(e, d.table, t, d.column), (t) => J(e, t, d.kind)) : M.die(/* @__PURE__ */ Error(`alter-column-type on mariadb needs the declared column '${d.table}.${d.column}' (to render MODIFY COLUMN); it was not in ctx.declared.`));
+					},
+					mssql: () => {
+						let t = z(i.declared, d.table, d.column);
+						if (!t) return M.die(/* @__PURE__ */ Error(`alter-column-type on mssql needs the declared column '${d.table}.${d.column}'.`));
+						if (d.using !== void 0) return M.fail(s(`SQL Server cannot apply a USING expression for ${d.table}.${d.column}; use a reviewed file migration for the explicit transform.`));
+						let n = ot(t, d.column, d.table);
+						return d.from === "integer" && d.to === "bigint" || d.from === "bigint" && d.to === "integer" ? Ce(e, d.table, d.column, n) : J(e, n, d.kind);
+					},
+					sqlite: () => Y(e, d.table, i.declared, d.kind),
+					orElse: () => J(e, `ALTER TABLE ${F(d.table)} ALTER COLUMN ${F(d.column)} TYPE ${t}${n};`, d.kind)
+				});
+				break;
+			}
+			yield* e.onDialectOrElse({
+				mysql: () => M.die(/* @__PURE__ */ Error(`online-required alter-column-type on ${d.table}.${d.column} is not supported on mariadb (the shadow-swap path is postgres-only). Use a smaller-table window or an external online-DDL tool.`)),
+				orElse: () => M.void
+			});
+			let a = `${d.column}__shadow`, o = `${d.column}__old`;
+			yield* e.unsafe(`ALTER TABLE ${F(d.table)} ADD COLUMN ${F(a)} ${t}`);
+			let c = d.using ?? F(d.column), l;
+			for (;;) {
+				let t = l === void 0 ? yield* e`SELECT ${e("id")} FROM ${e(d.table)} WHERE ${e(a)} IS NULL ORDER BY ${e("id")} ${k(e, 5e3)}` : yield* e`SELECT ${e("id")} FROM ${e(d.table)} WHERE ${e(a)} IS NULL AND ${e("id")} > ${l} ORDER BY ${e("id")} ${k(e, 5e3)}`;
+				if (t.length === 0) break;
+				yield* e.unsafe(`UPDATE ${F(d.table)} SET ${F(a)} = ${c} WHERE ${F(d.column)} IS NOT NULL AND ${F(a)} IS NULL AND ${F("id")} IN (${t.map((e) => `'${e.id.replace(/'/g, "''")}'`).join(",")})`), l = t[t.length - 1].id;
+			}
+			yield* M.logInfo(`alter-column-type shadow ${d.table}.${d.column}: shadow populated`).pipe(M.annotateLogs({ scope: "voltro:migrate" })), yield* e.unsafe(`ALTER TABLE ${F(d.table)} RENAME COLUMN ${F(d.column)} TO ${F(o)}`), yield* e.unsafe(`ALTER TABLE ${F(d.table)} RENAME COLUMN ${F(a)} TO ${F(d.column)}`), yield* e.unsafe(`ALTER TABLE ${F(d.table)} DROP COLUMN ${F(o)}`);
+			break;
+		}
+		case "drop-foreign-key":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Vt(d), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				orElse: () => J(e, Bt(d), d.kind)
+			});
+			break;
+		case "add-check":
+			yield* e.onDialectOrElse({
+				mysql: () => J(e, Ht(d, I), d.kind),
+				sqlite: () => Y(e, d.table, i.declared, d.kind),
+				orElse: () => J(e, Ht(d, F), d.kind)
+			});
+			break;
+		case "convert-charset":
+			yield* e.onDialectOrElse({
+				mysql: () => M.gen(function* () {
+					let { drops: t, rewrite: n, restores: r } = Ze(d, i.declared, yield* ze(e, d.table));
+					for (let n of t) yield* J(e, n, d.kind, [ge]);
+					yield* J(e, n, d.kind);
+					for (let t of r) yield* J(e, t, d.kind, [_e]);
+				}),
+				orElse: () => M.die(/* @__PURE__ */ Error("convert-charset requires MySQL or MariaDB"))
+			});
+			break;
+		case "reconcile-json-check": {
+			let t = K(d.column), n = d.validation === "value" ? b(t) : `(${t} IS NULL OR ISJSON(${t}) = 1)`;
+			yield* e.onDialectOrElse({
+				mssql: () => X(e, [...d.dropConstraints.map((e) => `ALTER TABLE ${K(d.table)} DROP CONSTRAINT ${K(e)}`), `ALTER TABLE ${K(d.table)} WITH CHECK ADD CHECK ${n}`], d.kind),
+				orElse: () => M.die(/* @__PURE__ */ Error("reconcile-json-check requires SQL Server"))
+			});
+			break;
+		}
+		case "drop-check": yield* e.onDialectOrElse({
+			mysql: () => Gt(e, d, i.declared),
+			sqlite: () => Y(e, d.table, i.declared, d.kind),
+			orElse: () => J(e, Ut(d), d.kind)
+		});
+	}
+	return {
+		op: d,
+		status: "applied",
+		durationMs: Number((process.hrtime.bigint() - l) / 1000000n)
+	};
+}), mn = (e, t, n, r, i) => M.gen(function* () {
+	let a = [...new Set(r.map((e) => e.runId))];
+	if (a.length > 1) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: the resume ledger holds ${a.length} unfinished runs (${a.join(", ")}). Only one migration may be in flight at a time — the advisory lock enforces it — so this means a run was interrupted and a LATER one wrote over it without clearing.\nNothing was changed. Inspect \`${h}\`, reconcile the schema by hand, and delete the rows of the run you have finished.`));
+	let o = a[0], s = [...r].map((e) => ({
+		index: Number(e.opIndex),
+		status: e.status,
+		planned: JSON.parse(e.payload)
+	})).sort((e, t) => e.index - t.index), c = s.find((e) => e.status === "started"), l = s.filter((e) => e.status === "started").length;
+	if (l > 1) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: the resume ledger records ${l} operations as in-flight for run ${o}. It is written strictly sequentially, so at most one can be — this ledger is corrupt and the schema state it describes cannot be trusted.\nNothing was changed. Reconcile \`${h}\` by hand before re-running.`));
+	let u = s.filter((e) => e.status === "added");
+	if (yield* M.logWarning(`migration resume: found an interrupted run (${o}) — ${s.filter((e) => e.status === "applied").length} of ${s.length} operation(s) completed${c ? `, in flight: ${c.planned.op.kind} ${ae(c.planned.op)}` : ""}${u.length > 0 ? `, ${u.length} column(s) added with the backfill still owed` : ""}`).pipe(M.annotateLogs({ scope: "voltro:migrate" })), s.every((e) => e.status === "pending")) return {
+		kind: "discard",
+		runId: o,
+		why: "no operation had started — no DDL ran"
+	};
+	let d = c && !(["sqlite", "turso"].includes(t) && c.planned.sqliteAtomicRebuild === !0) ? yield* fn(e, t, c.planned) : "clean";
+	d !== "clean" && (n = yield* i());
+	let f = r[0].planFingerprint;
+	if (f !== n.toFingerprint) return {
+		kind: "discard",
+		runId: o,
+		why: `the declared schema changed since the interruption (recorded target ${f.slice(0, 12)}…, current ${n.toFingerprint.slice(0, 12)}…) — applying the freshly-diffed plan instead`
+	};
+	let p = (e) => e.status === "applied" ? !1 : c && e.index === c.index && d !== "clean" ? d === "outstanding" : v(n, e.planned.op), m = s.filter(p), ee = s.filter((e) => e.status !== "applied" && !p(e));
+	return yield* cn(e, o, m.map((e) => e.index), ee.map((e) => e.index)), yield* M.logWarning(`migration resume: continuing run ${o} — replaying ${m.length} operation(s), ${s.length - m.length} already applied`).pipe(M.annotateLogs({ scope: "voltro:migrate" })), {
+		kind: "resume",
+		runId: o,
+		ops: m.map((e) => ({
+			index: e.index,
+			planned: e.planned
+		})),
+		history: s.filter((e) => e.status !== "pending" || p(e)).map((e) => e.planned)
+	};
+}), hn = (e, t, r) => M.gen(function* () {
+	let i, a = 0;
+	for (let o of t.operations) {
+		let s = o.op;
+		if (s.kind !== "add-index" || !s.index.unique || s.index.where === void 0) continue;
+		if (++a === 2 && t.operations.length >= 32) {
+			let e = /* @__PURE__ */ new Set();
+			for (let { op: n } of t.operations) n.kind === "rename-table" ? e.add(n.to) : (n.kind === "create-table" || n.kind === "add-column" || n.kind === "rename-column") && e.add(n.table);
+			i = e;
+		}
+		if (i === void 0 ? t.operations.some((e) => e.op.kind === "rename-table" ? e.op.to === s.table : e.op.table === s.table && [
+			"create-table",
+			"add-column",
+			"rename-column"
+		].includes(e.op.kind)) : i.has(s.table)) continue;
+		let c = s.index.columns.map((e) => e.startsWith("(") ? e : n(e, r)), l = r === "mssql" ? "" : c.map((e) => ` AND ${e} IS NOT NULL`).join(""), u = r === "mssql" ? "SELECT TOP (1) 1" : "SELECT 1", d = r === "mssql" ? "" : " LIMIT 1";
+		if ((yield* e.unsafe(`${u} FROM ${n(s.table, r)} WHERE (${s.index.where})${l} GROUP BY ${c.join(", ")} HAVING COUNT(*) > 1${d}`)).length > 0) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: partial unique index '${s.index.name}' on '${s.table}' conflicts with existing qualifying rows. No schema or row changes were applied. Resolve the conflicting data explicitly before retrying.`));
+	}
+}), gn = (e) => {
+	let t = e.op, n = (e) => typeof t[e] == "string" ? t[e] : "";
+	return [
+		t.kind,
+		n("table"),
+		n("column"),
+		n("name"),
+		n("to")
+	].join("\0");
+}, _n = (e, t, n) => M.acquireUseRelease(ee(e, { schema: n.lockSchema }), () => vn(e, t, n), (e) => e.release.pipe(M.orDie)), vn = (e, t, n) => M.gen(function* () {
+	let r = t.operations.filter((e) => e.blocked);
+	if (r.length > 0) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: refusing to execute — ${r.length} blocked operations. Run \`voltro db plan\` to see the fixes.`));
+	let i = Date.now(), a = [], c = _(e), l = yield* n.replan(e, "execution"), u = new Set(t.operations.filter((e) => !e.blocked).map((e) => gn(e))), d = {
+		...l,
+		operations: l.operations.map((e) => {
+			if (!e.blocked || !u.has(gn(e))) return e;
+			let { blocked: t, ...n } = e;
+			return n;
+		})
+	};
+	(d.operations.length !== t.operations.length || d.toFingerprint !== t.toFingerprint) && (yield* M.logInfo(`migration: re-planned under the lock — ${t.operations.length} operation(s) became ${d.operations.length}. Another writer changed the schema while this plan waited.`).pipe(M.annotateLogs({ scope: "voltro:migrate" })));
+	let f = d.operations.filter((e) => e.blocked);
+	if (f.length > 0) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: refusing to execute — re-planning under the migration lock found ${f.length} blocked operation(s). Run \`voltro db plan\` to see the fixes.`));
+	let p = ce(n.declared, c);
+	p && (yield* J(e, p, "extensions"));
+	let m = oe(n.declared, c);
+	m && (yield* J(e, m, "enum-types"));
+	let ee = se(n.declared, c);
+	ee && (yield* J(e, ee, "enum-types"));
+	let h = ie(c) === "plan-transactional";
+	yield* hn(e, d, c), yield* Qt(e, c, n.charset);
+	let te = yield* an(e), g = te.length > 0 ? yield* mn(e, c, d, te, () => n.replan(e, "execution").pipe(M.map((e) => (d = {
+		...e,
+		operations: e.operations.map((e) => {
+			if (!e.blocked || !u.has(gn(e))) return e;
+			let { blocked: t, ...n } = e;
+			return n;
+		})
+	}, d)))) : void 0;
+	if (d.operations.some((e) => e.blocked)) return yield* M.die(/* @__PURE__ */ Error("applyPlan: refusing blocked operations after interrupted-run repair. Run `voltro db plan` to inspect the remaining work."));
+	g?.kind === "discard" && (yield* M.logWarning(`migration resume: discarding ledger of run ${g.runId} — ${g.why}`).pipe(M.annotateLogs({ scope: "voltro:migrate" })), yield* ln(e, g.runId));
+	let ne = (/* @__PURE__ */ new Date()).toISOString(), re = process.env.VOLTRO_SOFT_DROP === "1" ? d.operations.map((e) => pe(e, ne)) : d.operations, v = h ? re.filter((e) => e.classification !== "online-required") : [], ae = h ? re.filter((e) => e.classification === "online-required") : re, y = `plan_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`, b = ae.map((e, t) => ({
+		index: v.length + t,
+		planned: e
+	})), x = "fresh", S;
+	g?.kind === "resume" && (y = g.runId, b = g.ops, S = g.history, x = "resume"), (v.length > 0 || b.length > 0) && n.beforeExecute !== void 0 && (yield* n.beforeExecute), x === "fresh" && b.length > 0 && (yield* sn(e, y, d.toFingerprint, b)), v.length > 0 && (yield* xe(e, M.gen(function* () {
+		let e = yield* Ee.SqlClient;
+		if (x === "resume") return yield* M.die(/* @__PURE__ */ Error("applyPlan: transactional work appeared while resuming an interrupted run with the same target. Inspect the live schema and operation ledger before retrying."));
+		let t = v.map((e, t) => ({
+			index: t,
+			planned: e
+		}));
+		yield* sn(e, y, d.toFingerprint, t);
+		let r = [], i = () => M.gen(function* () {
+			for (let e of r.splice(0)) yield* e.data, yield* e.after;
+		});
+		for (let t of v) qt.has(t.op.kind) && r.length > 0 && (yield* i()), a.push(yield* pn(e, t, n, "fresh", (e) => r.push(e)));
+		yield* i();
+		for (let { index: n } of t) yield* $(e, y, n, "applied");
+	})));
+	let C = [], w = () => M.gen(function* () {
+		let t = C.splice(0);
+		if (t.length !== 0) {
+			yield* xe(e, M.gen(function* () {
+				for (let e of t) yield* e.data;
+			}));
+			for (let n of t) yield* n.after, a.push({
+				op: n.op,
+				status: "applied",
+				durationMs: Number(process.hrtime.bigint() - n.startedAt) / 1e6
+			}), yield* $(e, y, n.index, "applied", Number(process.hrtime.bigint() - n.startedAt) / 1e6);
+		}
+	});
+	for (let { index: t, planned: r } of b) {
+		qt.has(r.op.kind) && C.length > 0 && (yield* w()), yield* $(e, y, t, "started", void 0, r);
+		let i = a.length, o = process.hrtime.bigint(), c = yield* pn(e, r, n, x, (e) => C.push({
+			...e,
+			index: t,
+			startedAt: o
+		})).pipe(M.mapError((e) => s(`${String(e?.message ?? e)}\n\n  progress: ${i} of ${b.length + v.length} operation(s) applied before this one${v.length > 0 ? ` (${v.length} of them in a transaction)` : ""}.\n` + (h ? (v.length > 0 ? "The transactional batch completed before this phase; this failure does not roll it back.\n" : "This phase runs outside a transactional batch; completed operations are not rolled back by this failure.\n") + "An enclosing deployment transaction may still undo its own changes. Inspect the live schema and operation ledger before retrying.\nThe failing operation may also have made partial progress.\n" : `  This dialect does NOT apply a plan atomically: those ${i} are COMMITTED and there is no rollback.\n  The ledger records how far it got (operation ${t} was in flight).\n`), e)));
+		c.deferred === !0 ? yield* $(e, y, t, "added") : (a.push(c), yield* $(e, y, t, "applied", c.durationMs));
+	}
+	yield* w();
+	let T = yield* n.replan(e, "convergence");
+	if (T.operations.length > 0) {
+		let e = (e) => "column" in e ? typeof e.column == "string" ? `.${e.column}` : `.${String(e.column.name ?? "")}` : "", t = T.operations.slice(0, 10).map((t) => `  - ${t.op.kind} ${"table" in t.op ? t.op.table : ""}${e(t.op)}`).join("\n"), n = a.filter((e) => e.status === "applied"), r = n.slice(0, 10).map((t) => `    - ${t.op.kind} ${"table" in t.op ? t.op.table : ""}${e(t.op)}`).join("\n") + (n.length > 10 ? `\n    … and ${n.length - 10} more` : "");
+		return yield* M.die(/* @__PURE__ */ Error(`applyPlan: the migration did not converge. ${d.operations.length} operation(s) were executed without error, but re-planning against the live schema still finds ${T.operations.length}:\n${t}${T.operations.length > 10 ? `\n  … and ${T.operations.length - 10} more` : ""}\nNo fingerprint was recorded — recording one would make the next boot report "schema up to date" for a schema that was never applied. This is a framework bug.\n` + (h ? (v.length > 0 ? "The transactional batch completed before this convergence check; this check does not roll it back.\n" : "This convergence check does not roll back completed operations; this plan had no transactional batch.\n") + `An enclosing deployment transaction may still undo its own changes. Inspect the live schema and operation ledger before retrying.\nOperations reported applied before this check:\n${r}\n` : `  This dialect does NOT apply a plan atomically. The ${n.length} operation(s) below are COMMITTED\n  and there is no rollback — the schema is PART-APPLIED, not unchanged:\n${r}\n  Re-running plans from where the database now is, which is a different plan from the one that failed.\n`) + "Two causes look identical from here, so read the list before assuming either:\n  - the DDL for those operations is a no-op (it succeeded and changed nothing), or\n  - the planner cannot see what the DDL did, so it proposes the same work again — which is what an\n    operation naming an object a PREVIOUS operation created or renamed usually means.\nReport the operation kinds above with the column types involved."));
+	}
+	let le = a.filter((e) => e.status === "applied").length, ue = Date.now() - i, E = y, de = (/* @__PURE__ */ new Date()).toISOString(), fe = yield* j(e, de), D = [...v, ...S ?? b.map((e) => e.planned)], O = x === "resume" ? yield* e`SELECT ${e("fingerprint")}, ${e("operations")}
+          FROM ${e("_voltro_migration_plans")} WHERE ${e("id")} = ${E}` : [];
+	if (O.length > 0) {
+		let e = O[0], t = typeof e.operations == "string" ? JSON.parse(e.operations) : e.operations;
+		if (e.fingerprint !== d.toFingerprint || !Array.isArray(t) || !we(t, JSON.parse(JSON.stringify(D)))) return yield* M.die(/* @__PURE__ */ Error(`applyPlan: history for resumed run ${E} does not match its recorded operations; the resume ledger was retained.`));
+	}
+	O.length === 0 && (yield* e`
+      INSERT INTO ${e("_voltro_migration_plans")}
+        (${e("id")}, ${e("fingerprint")}, ${e("liveFingerprint")}, ${e("operations")},
+         ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+         ${e("durationMs")}, ${e("appliedAt")}, ${e("notes")})
+      VALUES
+        (${E}, ${d.toFingerprint}, ${T.fromFingerprint}, ${JSON.stringify(D)},
+         ${n.appliedBy}, ${n.environment}, ${n.source},
+         ${ue}, ${fe}, ${n.notes ?? null})
+    `.pipe(M.mapError((e) => s(`${String(e?.message ?? e)}\n\nMigration ${E}: schema work completed, but writing its history failed.\nThe operation ledger is retained for recovery. This error does not establish whole-plan rollback; inspect the live schema before retrying.`, e)))), yield* ln(e, y).pipe(M.mapError((e) => s(`${String(e?.message ?? e)}\n\nMigration ${E}: the history row was written, but operation-ledger cleanup failed.\nAn enclosing transaction may still roll back its own changes. Inspect the recorded history and any remaining operation ledger before retrying; do not assume the schema is unchanged.`, e)));
+	let me = [...new Set(D.flatMap((e) => e.op.kind === "rename-table" ? [e.op.to] : [e.op.table]))];
+	return yield* M.promise(() => o({ changedTables: me }).catch(() => {})), {
+		id: E,
+		appliedAt: de,
+		fingerprint: d.toFingerprint,
+		operations: D,
+		appliedBy: n.appliedBy,
+		environment: n.environment,
+		durationMs: ue,
+		appliedOps: le,
+		source: n.source,
+		...n.notes ? { notes: n.notes } : {}
+	};
+}), yn = (e, t) => {
+	switch (t.kind) {
+		case "drop-foreign-key": return {
+			...e,
+			columns: e.columns.map((e) => {
+				if (e.name !== t.column) return e;
+				let { references: n, ...r } = e;
+				return r;
+			})
+		};
+		case "drop-index": return {
+			...e,
+			indexes: e.indexes.filter((e) => e.name !== t.index)
+		};
+		case "drop-column": return {
+			...e,
+			columns: e.columns.filter((e) => e.name !== t.column),
+			indexes: e.indexes.filter((e) => !e.columns.includes(t.column))
+		};
+		case "rename-column": return {
+			...e,
+			columns: e.columns.map((e) => e.name === t.from ? {
+				...e,
+				name: t.to
+			} : e),
+			indexes: e.indexes.map((e) => ({
+				...e,
+				columns: e.columns.map((e) => e === t.from ? t.to : e)
+			})),
+			...e.primaryKey === void 0 ? {} : { primaryKey: e.primaryKey.map((e) => e === t.from ? t.to : e) }
+		};
+	}
+}, bn = (e, t, n) => {
+	let r = n.tables.find((e) => e.name === t.table), i = () => r === void 0 ? M.void : Yt(e, t.table, at(yn(r, t)), t.kind);
+	switch (t.kind) {
+		case "drop-foreign-key": return e.onDialectOrElse({
+			mysql: () => J(e, Vt(t), t.kind),
+			sqlite: i,
+			orElse: () => J(e, Bt(t), t.kind)
+		});
+		case "drop-index": return e.onDialectOrElse({
+			mysql: () => J(e, bt(t), t.kind),
+			mssql: () => J(e, xt(t), t.kind),
+			orElse: () => J(e, yt(t), t.kind)
+		});
+		case "drop-column": return e.onDialectOrElse({
+			mysql: () => A(e).pipe(M.flatMap((n) => J(e, Me(t, n), t.kind, [he]))),
+			sqlite: i,
+			orElse: () => J(e, L(t, F), t.kind)
+		});
+		case "rename-column": return e.onDialectOrElse({
+			mysql: () => J(e, R(t, I), t.kind),
+			mssql: () => Xt(e, t),
+			orElse: () => J(e, R(t, F), t.kind)
+		});
+	}
+}, xn = (e, t, n) => pn(e, t, { declared: n });
+//#endregion
+export { Kt as addColumnDdl, un as appliedLedgerOperations, _n as applyPlan, dn as clearResumeLedger, ze as columnLevelChecksMysql, _t as emitAddIndexMysql, Ze as emitConvertCharsetMysql, ut as emitCreateTableMssql, Qe as emitCreateTableMysql, We as emitCreateTablePg, rt as emitCreateTableSqlite, L as emitDropColumnDdl, Me as emitDropColumnDdlMysql, nn as ensureDeployLedgerTable, Qt as ensureLedgerTable, $t as ensurePlanLedgerTable, tn as ensurePluginMigrationsLedgerTable, rn as ensureReplaceMarkerTable, en as ensureSchemaOwnerTable, on as hasInterruptedMigration, pt as mysqlIndexPrefixFor, Je as renderColumnMysql, Ue as renderColumnPg, xn as runMigrationOp, bn as runSchemaOp };