@voltro/database 0.1.0

package/dist/sql.js

@@ -0,0 +1,2569 @@
+import { L as e, R as t, V as n, a as r, c as i, et as a, i as o, n as s, ot as c, r as l, t as u } from "./fileBased-cc9IzIjU.js";
+import { Effect as d } from "effect";
+import { createLogger as f } from "@voltro/logger";
+import { SqlClient as p } from "@effect/sql";
+import { createHash as m } from "node:crypto";
+import { promises as h } from "node:fs";
+import { join as g } from "node:path";
+import { pathToFileURL as ee } from "node:url";
+//#region src/migrations/ddlError.ts
+var _ = (e, t, n, r = 400) => {
+	let i = n, a = i.cause ?? {}, o = (e) => {
+		let t = a[e];
+		return t == null || t === "" ? void 0 : String(t);
+	}, s = [
+		"",
+		`═══ ${e} ═══`,
+		`statement: ${t.replace(/\s+/g, " ").slice(0, r)}${t.length > r ? " …" : ""}`,
+		`db.message: ${o("sqlMessage") ?? o("message") ?? i.message ?? "(none)"}`
+	];
+	for (let e of [
+		"code",
+		"errno",
+		"sqlState",
+		"number",
+		"state",
+		"class",
+		"lineNumber",
+		"procName",
+		"serverName",
+		"detail",
+		"hint",
+		"table",
+		"column",
+		"constraint",
+		"position",
+		"routine"
+	]) {
+		let t = o(e);
+		t !== void 0 && s.push(`db.${e}: ${t}`);
+	}
+	return s.push(""), s.join("\n");
+}, v = (e, t) => `${e}::${t}`, y = (e, t) => {
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), a = (e) => {
+		n.add(e);
+		let o = [...t(e)].filter((t) => t.target !== e).sort((e, t) => e.column.localeCompare(t.column));
+		for (let t of o) n.has(t.target) ? i.add(v(e, t.column)) : r.has(t.target) || a(t.target);
+		n.delete(e), r.add(e);
+	};
+	for (let t of [...e].sort()) r.has(t) || a(t);
+	return i;
+}, b = 6322741009312437n, x = 250, S = () => {
+	let e = Number(process.env.VOLTRO_MIGRATION_LOCK_TIMEOUT_MS);
+	return Number.isFinite(e) && e > 0 ? e : 3e4;
+}, C = (e) => d.gen(function* () {
+	let t = S(), n = Date.now();
+	for (;;) {
+		if ((yield* e`
+        SELECT pg_try_advisory_lock(${"6322741009312437"}::bigint) AS got`)[0]?.got) return;
+		Date.now() - n >= t && (yield* d.die(/* @__PURE__ */ Error(`could not acquire the postgres migration advisory lock within ${Math.round(t / 1e3)}s. Another migration is in progress, or a prior boot crashed while holding it. (A crashed process's session-level advisory lock is released once its DB connection closes; if this persists, find + terminate the holder via pg_stat_activity, or raise VOLTRO_MIGRATION_LOCK_TIMEOUT_MS.)`))), yield* d.sleep(`${x} millis`);
+	}
+}), te = (e) => d.gen(function* () {
+	yield* e`SELECT pg_advisory_unlock(${b.toString()}::bigint)`;
+}), ne = `voltro_migration_${b.toString(36)}`, re = 30, ie = (e) => d.gen(function* () {
+	(yield* e`
+      SELECT GET_LOCK(${ne}, ${re}) AS got`)[0]?.got !== 1 && (yield* d.die(/* @__PURE__ */ Error(`could not acquire the migration lock '${ne}' within ${re}s (another migration is in progress, or a prior one left it held).`)));
+}), ae = (e) => d.gen(function* () {
+	yield* e`SELECT RELEASE_LOCK(${ne})`;
+}), oe = `voltro_migration_${b.toString(36)}`, se = 3e4, ce = (e) => d.gen(function* () {
+	let t = yield* e`
+      DECLARE @res int;
+      EXEC @res = sp_getapplock @Resource = ${oe}, @LockMode = 'Exclusive',
+        @LockOwner = 'Session', @LockTimeout = ${se};
+      SELECT @res AS res`;
+	(t[0]?.res ?? -999) < 0 && (yield* d.die(/* @__PURE__ */ Error(`could not acquire the migration lock '${oe}' (sp_getapplock returned ${t[0]?.res ?? "no row"}; another migration is in progress).`)));
+}), le = (e) => d.gen(function* () {
+	yield* e`EXEC sp_releaseapplock @Resource = ${oe}, @LockOwner = 'Session'`;
+}), ue = d.void, w = (e) => e.onDialectOrElse({
+	mysql: () => ie(e),
+	mssql: () => ce(e),
+	sqlite: () => ue,
+	orElse: () => C(e)
+}), T = (e) => e.onDialectOrElse({
+	mysql: () => ae(e),
+	mssql: () => le(e),
+	sqlite: () => ue,
+	orElse: () => te(e)
+}), E = (e, t) => d.acquireUseRelease(w(e), () => t, () => T(e).pipe(d.orDie)), de = f({ scope: "voltro:migrate" }), D = (e) => {
+	de.warn(e.replace(/^\[voltro:migrate\]\s*/, ""));
+}, O = (t, n) => {
+	let r = t.type;
+	if (t.spatial) {
+		if (n === "postgres") return `${t.spatial.kind}(${t.spatial.geomKind},${t.spatial.srid})`;
+		throw Error(`@voltro/plugin-postgis: ${t.spatial.kind}('${t.spatial.geomKind}', ${t.spatial.srid}) is postgres-only — the active dialect is '${n}'. PostGIS has no portable equivalent; use store: 'postgres' (or DB_DIALECT=postgres) for spatial columns, or model the value as plain text/json.`);
+	}
+	if (r === "raw") {
+		if (t.rawDdl === void 0) throw Error("raw() column is missing its DDL fragment — this is a framework bug.");
+		return t.rawDdl;
+	}
+	if (r === "array" && t.arrayElement) {
+		if (n === "postgres") return `${O({
+			...t,
+			type: t.arrayElement,
+			arrayElement: void 0
+		}, n)}[]`;
+		if (n === "mysql" || n === "mariadb") return "JSON";
+		if (n === "mssql") return "NVARCHAR(MAX)";
+		if (e(n)) return "TEXT";
+	}
+	if (r === "vector") {
+		let r = t.vectorDim;
+		if (r === void 0) throw Error("vector column is missing its dimension — this is a framework bug.");
+		let i = t.vectorPrecision === "half";
+		if (n === "postgres") return i ? `HALFVEC(${r})` : `VECTOR(${r})`;
+		if (n === "mysql" || n === "mariadb") return `VECTOR(${r})`;
+		if (n === "mssql") return "VARBINARY(MAX)";
+		if (e(n)) return "BLOB";
+	}
+	if (r === "interval") {
+		if (n === "postgres") return "INTERVAL";
+		if (n === "mysql" || n === "mariadb" || n === "mssql") return "BIGINT";
+		if (e(n)) return "INTEGER";
+	}
+	if (r === "decimal") {
+		let r = t.precision, i = t.scale ?? 0;
+		if (r === void 0) throw Error("decimal column is missing its precision — this is a framework bug.");
+		return e(n) ? "NUMERIC" : n === "postgres" ? `NUMERIC(${r}, ${i})` : `DECIMAL(${r}, ${i})`;
+	}
+	if (r === "bigint") return e(n) ? "INTEGER" : "BIGINT";
+	if (r === "enum") {
+		if (n === "postgres") return t.enumName ?? "TEXT";
+		if (n === "mysql" || n === "mariadb") return `ENUM(${(t.enumValues ?? []).map((e) => `'${e.replace(/'/g, "''")}'`).join(", ")})`;
+		if (n === "mssql") return "NVARCHAR(255)";
+		if (e(n)) return "TEXT";
+	}
+	if (r === "text" && t.maxLength !== void 0 && t.generatedAs === void 0) return n === "mssql" ? `NVARCHAR(${t.maxLength})` : e(n) ? "TEXT" : `VARCHAR(${t.maxLength})`;
+	if (e(n)) switch (r) {
+		case "id": return "TEXT";
+		case "text": return "TEXT";
+		case "integer": return "INTEGER";
+		case "real": return "REAL";
+		case "boolean": return "INTEGER";
+		case "timestamp": return "TEXT";
+		case "date": return "TEXT";
+		case "json": return "TEXT";
+		case "bytes": return "BLOB";
+		case "reference": return "TEXT";
+		case "vector": return "BLOB";
+		case "enum": return "TEXT";
+		case "array": return "TEXT";
+		case "interval": return "INTEGER";
+	}
+	if (n === "mysql" || n === "mariadb") switch (r) {
+		case "id": return "VARCHAR(64)";
+		case "text": return t.hasDefault && t.defaultFactory === void 0 || t.oneOf && t.oneOf.length > 0 ? "VARCHAR(255)" : t.generatedAs ? "TEXT" : "LONGTEXT";
+		case "integer": return "INT";
+		case "real": return "DOUBLE";
+		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 "VARCHAR(64)";
+		case "vector": return "VECTOR(0)";
+		case "enum": return "TEXT";
+		case "array": return "JSON";
+		case "interval": return "BIGINT";
+	}
+	if (n === "mssql") switch (r) {
+		case "id": return "NVARCHAR(64)";
+		case "text": return t.hasDefault && t.defaultFactory === void 0 || t.oneOf && t.oneOf.length > 0 ? "NVARCHAR(450)" : "NVARCHAR(MAX)";
+		case "integer": return "INT";
+		case "real": return "FLOAT";
+		case "boolean": return "BIT";
+		case "timestamp": return "DATETIME2(6)";
+		case "date": return "DATE";
+		case "json": return "NVARCHAR(MAX)";
+		case "bytes": return "VARBINARY(MAX)";
+		case "reference": return "NVARCHAR(64)";
+		case "vector": return "VARBINARY(MAX)";
+		case "enum": return "NVARCHAR(255)";
+		case "array": return "NVARCHAR(MAX)";
+		case "interval": return "BIGINT";
+	}
+	switch (r) {
+		case "id": return "TEXT";
+		case "text": return "TEXT";
+		case "integer": return "INTEGER";
+		case "real": return "DOUBLE PRECISION";
+		case "boolean": return "BOOLEAN";
+		case "timestamp": return "TIMESTAMPTZ";
+		case "date": return "DATE";
+		case "json": return "JSONB";
+		case "bytes": return "BYTEA";
+		case "reference": return "TEXT";
+		case "vector": return "VECTOR";
+		case "enum": return t.enumName ?? "TEXT";
+		case "array": return "TEXT[]";
+		case "interval": return "INTERVAL";
+	}
+}, fe = (t, n) => {
+	if (!t.hasDefault || t.defaultFactory !== void 0) return null;
+	let r = t.defaultValue;
+	return r === "now" ? e(n) ? "DEFAULT CURRENT_TIMESTAMP" : n === "mssql" ? "DEFAULT SYSUTCDATETIME()" : n === "mysql" || n === "mariadb" ? "DEFAULT CURRENT_TIMESTAMP(6)" : "DEFAULT now()" : typeof r == "boolean" ? n === "postgres" ? `DEFAULT ${r}` : `DEFAULT ${+!!r}` : typeof r == "number" ? `DEFAULT ${r}` : typeof r == "string" ? `DEFAULT '${r.replace(/'/g, "''")}'` : typeof r == "object" && r && !Array.isArray(r) ? k(r, n) : null;
+}, k = (e, t) => {
+	let n = JSON.stringify(e).replace(/'/g, "''");
+	return t === "postgres" ? `DEFAULT '${n}'::jsonb` : t === "mysql" || t === "mariadb" ? `DEFAULT (CAST('${n}' AS JSON))` : `DEFAULT '${n}'`;
+}, A = (e, t) => {
+	switch (t) {
+		case "postgres": return `"${e}" BIGSERIAL PRIMARY KEY`;
+		case "mysql":
+		case "mariadb": return `\`${e}\` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY`;
+		case "mssql": return `[${e}] BIGINT IDENTITY(1,1) PRIMARY KEY`;
+		case "sqlite": return `"${e}" INTEGER PRIMARY KEY AUTOINCREMENT`;
+		case "turso": return `"${e}" INTEGER PRIMARY KEY`;
+	}
+}, j = (e, t) => {
+	if (e === "restrict" && t === "mssql") return "NO ACTION";
+	switch (e) {
+		case "cascade": return "CASCADE";
+		case "restrict": return "RESTRICT";
+		case "setNull": return "SET NULL";
+		case "noAction": return "NO ACTION";
+	}
+}, pe = (e, n, r) => r === null ? t(e, n) : `${t(r, n)}.${t(e, n)}`, me = 191, he = (e, n, r) => {
+	let i = t(e, r);
+	if (r !== "mysql" && r !== "mariadb") return i;
+	let a = n[e];
+	if (!a) return i;
+	let o = O(a, r).toUpperCase();
+	return o.endsWith("TEXT") || o.endsWith("BLOB") ? `${i}(${me})` : i;
+}, ge = (e, t) => {
+	if (!e.generatedAs) return null;
+	let { expr: n, stored: r } = e.generatedAs;
+	if (t === "postgres") return r || D("[voltro:migrate] generated column requested as VIRTUAL but postgres only supports STORED — promoting"), `GENERATED ALWAYS AS (${n}) STORED`;
+	if (t === "mysql" || t === "mariadb") return `GENERATED ALWAYS AS (${n}) ${r ? "STORED" : "VIRTUAL"}`;
+	if (t === "mssql") return `AS (${n})${r ? " PERSISTED" : ""}`;
+	if (t === "turso") throw Error("@voltro/sql-turso: generated columns (.generatedAs(...)) are not supported — Turso's MVCC mode (journal_mode=experimental_mvcc) rejects them. Drop the generated column, or use the 'sqlite' / 'postgres' dialect for this table.");
+	return `GENERATED ALWAYS AS (${n}) ${r ? "STORED" : "VIRTUAL"}`;
+}, _e = (n, r, i, a, o = !1, s = !1) => {
+	if (r.type === "id" && r.idScheme?.kind === "numeric") return A(n, i);
+	let c = i === "mssql" && r.type === "text" && !r.generatedAs && r.maxLength === void 0 && a?.has(n) ? "NVARCHAR(450)" : O(r, i), l = [t(n, i), c];
+	r.type === "id" && !s && l.push("PRIMARY KEY");
+	let u = ge(r, i);
+	if (u) l.push(u);
+	else {
+		r.nullable || l.push("NOT NULL"), r.unique && r.type !== "id" && l.push("UNIQUE");
+		let e = fe(r, i);
+		e && l.push(e);
+	}
+	if (r.type === "reference" && r.references && !o) {
+		let e = r.references();
+		l.push(`REFERENCES ${t(e.tableName, i)} (${t("id", i)})`);
+		let n = j(r.onDelete ?? "restrict", i);
+		l.push(`ON DELETE ${n}`);
+		let a = j(r.refOnUpdate ?? "noAction", i);
+		a !== "NO ACTION" && l.push(`ON UPDATE ${a}`);
+	}
+	if (r.oneOf && r.oneOf.length > 0) {
+		let e = r.oneOf.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		l.push(`CHECK (${t(n, i)} IN (${e}))`);
+	}
+	if (r.checks && r.checks.length > 0) for (let e of r.checks) l.push(`CHECK (${e})`);
+	if (r.type === "enum" && r.enumValues && r.enumValues.length > 0 && (i === "mssql" || e(i))) {
+		let e = r.enumValues.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		l.push(`CHECK (${t(n, i)} IN (${e}))`);
+	}
+	if (r.type === "json" || r.type === "array") {
+		let r = t(n, i);
+		e(i) ? l.push(`CHECK (${r} IS NULL OR json_valid(${r}))`) : i === "mssql" && l.push(`CHECK (${r} IS NULL OR ISJSON(${r}) = 1)`);
+	}
+	return l.join(" ");
+}, ve = (e, n, r = null, i) => {
+	let a = /* @__PURE__ */ new Set();
+	for (let t of e.appliedIndexes ?? []) for (let e of t.fields) typeof e == "string" && a.add(e);
+	for (let t of e.appliedUniques ?? []) for (let e of t.fields) typeof e == "string" && a.add(e);
+	let o = e.appliedPrimaryKey ?? [], s = o.length > 0, c = Object.entries(e.fields).map(([e, t]) => `  ${_e(e, t, n, a, i?.has(e) ?? !1, s)}`).join(",\n"), l = (e.appliedUniques ?? []).map((r) => {
+		let i = r.fields.map((t) => he(t, e.fields, n)).join(", ");
+		return `  CONSTRAINT ${t(r.name, n)} UNIQUE (${i})`;
+	}), u = (e.appliedChecks ?? []).map((e) => `  CONSTRAINT ${t(e.name, n)} CHECK (${e.expr})`), d = [
+		...s ? [`  PRIMARY KEY (${o.map((t) => he(t, e.fields, n)).join(", ")})`] : [],
+		...l,
+		...u
+	], f = d.length > 0 ? `${c},\n${d.join(",\n")}` : c, p = pe(e.tableName, n, r);
+	if (n === "mssql") {
+		let t = r === null ? e.tableName : `${r}.${e.tableName}`, n = `CREATE TABLE ${p} (\n${f}\n)`;
+		return `IF OBJECT_ID('${t.replace(/'/g, "''")}', 'U') IS NULL EXEC(N'${n.replace(/'/g, "''")}');`;
+	}
+	return [
+		`CREATE TABLE IF NOT EXISTS ${p} (`,
+		f,
+		");"
+	].join("\n");
+}, ye = (e, n, r) => {
+	let i = `${e}_${n.name}_fts`, a = (e) => t(e, r), o = n.columns.map(a).join(", "), s = n.columns.map((e) => `new.${a(e)}`).join(", "), c = [];
+	return c.push(`CREATE VIRTUAL TABLE IF NOT EXISTS ${a(i)} USING fts5(${o}, row_id UNINDEXED, tokenize='porter');`), c.push(`CREATE TRIGGER IF NOT EXISTS ${a(`${i}_ai`)} AFTER INSERT ON ${a(e)} BEGIN\n  INSERT INTO ${a(i)} (${o}, row_id) VALUES (${s}, new.${a("id")});\nEND;`), c.push(`CREATE TRIGGER IF NOT EXISTS ${a(`${i}_ad`)} AFTER DELETE ON ${a(e)} BEGIN\n  DELETE FROM ${a(i)} WHERE row_id = old.${a("id")};\nEND;`), c.push(`CREATE TRIGGER IF NOT EXISTS ${a(`${i}_au`)} AFTER UPDATE ON ${a(e)} BEGIN\n  DELETE FROM ${a(i)} WHERE row_id = old.${a("id")};\n  INSERT INTO ${a(i)} (${o}, row_id) VALUES (${s}, new.${a("id")});\nEND;`), c;
+}, be = (e, r, i = null) => {
+	let a = [], s = /* @__PURE__ */ new Set(), c = (e) => e.join("\0"), l = (e, t, i, a) => {
+		let o = {
+			using: "",
+			withSuffix: "",
+			skip: !1
+		};
+		if (i === void 0 || i === "btree") return o;
+		if (i === "gist") return r === "postgres" ? {
+			using: " USING GIST",
+			withSuffix: "",
+			skip: !1
+		} : (D(`[voltro:migrate] index '${e}' on '${t}': ${r} doesn't support GiST — falling back to btree. Spatial queries on this column will fall back to sequential scan.`), o);
+		if (i === "gin") return r === "postgres" ? {
+			using: " USING GIN",
+			withSuffix: "",
+			skip: !1
+		} : r === "mysql" || r === "mariadb" ? (D(`[voltro:migrate] gin index '${e}' on '${t}': ${r} has no GIN access method — skipping (a btree on a JSON/array column can't serve containment/membership queries). Add a generated column for the specific path you query, then index that with .expressionIndex(...).`), {
+			using: "",
+			withSuffix: "",
+			skip: !0
+		}) : (D(`[voltro:migrate] gin index '${e}' on '${t}': ${r} has no GIN access method — falling back to btree. Containment/membership queries won't use this index efficiently.`), o);
+		if (i === "brin") return r === "postgres" ? {
+			using: " USING BRIN",
+			withSuffix: "",
+			skip: !1
+		} : (D(`[voltro:migrate] brin index '${e}' on '${t}': ${r} has no BRIN access method — falling back to btree (larger on disk, but the range scan still works).`), o);
+		if (i === "hnsw") {
+			if (r === "postgres") {
+				let e = a?.hnsw?.m ?? 16, t = a?.hnsw?.efConstruction ?? 64, r = a?.hnsw?.opclass ?? n(a?.hnsw?.distance);
+				return {
+					using: " USING hnsw",
+					withSuffix: ` WITH (m = ${e}, ef_construction = ${t})`,
+					opclass: r,
+					skip: !1
+				};
+			}
+			return D(`[voltro:migrate] hnsw index '${e}' on '${t}': ${r} has no pgvector / HNSW access method — skipping. Nearest-neighbour queries on this column fall back to a sequential scan.`), {
+				using: "",
+				withSuffix: "",
+				skip: !0
+			};
+		}
+		return o;
+	}, u = (t, n) => {
+		let i = t.map((t) => {
+			if (typeof t == "string") return he(t, e.fields, r);
+			if ("jsonPath" in t) {
+				let { column: e, path: n, numeric: i } = t.jsonPath;
+				return `(${o(e, n, r, { numeric: i })})`;
+			}
+			return `(${t.expr})`;
+		});
+		return n !== void 0 && i.length === 1 ? `${i[0]} ${n}` : i.join(", ");
+	}, d = (e, n, a, o, s, c = "") => {
+		let d = l(e, n, o, s);
+		if (d.skip) return "";
+		let f = u(a, d.opclass), p = `${d.withSuffix}${c}`, m = pe(n, r, i);
+		return r === "mssql" ? `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '${e}') CREATE INDEX ${t(e, r)} ON ${m}${d.using} (${f})${p};` : r === "mysql" ? `CREATE INDEX ${t(e, r)} ON ${m}${d.using} (${f})${p};` : `CREATE INDEX IF NOT EXISTS ${t(e, r)} ON ${m}${d.using} (${f})${p};`;
+	};
+	for (let n of e.appliedFullText ?? []) if (r === "postgres") {
+		let i = n.config ?? "english", o = `${n.name}_tsv`, s = n.columns.map((e) => {
+			let a = n.weights?.[e] ?? "A";
+			return `setweight(to_tsvector('${i}', coalesce(${t(e, r)}, '')), '${a}')`;
+		}).join(" || ");
+		a.push(`ALTER TABLE ${t(e.tableName, r)} ADD COLUMN IF NOT EXISTS ${t(o, r)} tsvector GENERATED ALWAYS AS (${s}) STORED;`), a.push(`CREATE INDEX IF NOT EXISTS ${t(n.name, r)} ON ${t(e.tableName, r)} USING GIN (${t(o, r)});`);
+	} else if (r === "mysql" || r === "mariadb") {
+		let i = n.columns.map((e) => t(e, r)).join(", ");
+		a.push(`CREATE FULLTEXT INDEX ${t(n.name, r)} ON ${t(e.tableName, r)} (${i});`);
+	} else if (r === "turso") throw Error(`@voltro/sql-turso: full-text index '${n.name}' on '${e.tableName}' is not supported — Turso's MVCC mode has no FTS5 virtual tables. Drop .fullTextIndex(), or use the 'sqlite' / 'postgres' dialect for this table.`);
+	else r === "sqlite" ? a.push(...ye(e.tableName, n, r)) : D(`[voltro:migrate] full-text index '${n.name}' on '${e.tableName}': ${r} uses a ranked LIKE search at query time (no native FTS catalog required).`);
+	for (let t of e.appliedIndexes) {
+		if ((r === "mariadb" || r === "mssql") && t.fields.some((e) => typeof e != "string" && "jsonPath" in e)) {
+			D(`[voltro:migrate] json-path index '${t.name}' on '${e.tableName}': ${r} cannot index a JSON expression directly — skipping. For an indexed JSON path on ${r}, add a generated column for the path (text().generatedAs(...) / .stored()) and .index([...]) it, then filter on that column instead of jsonField(...).`);
+			continue;
+		}
+		let n = "";
+		t.where !== void 0 && t.where.length > 0 && (r === "mysql" || r === "mariadb" ? D(`[voltro:migrate] partial index '${t.name}' on '${e.tableName}': ${r} does not support WHERE clauses on indexes — emitting a full index`) : n = ` WHERE ${t.where}`);
+		let i = d(t.name, e.tableName, t.fields, t.kind, t.kindOptions, n);
+		i !== "" && a.push(i), t.fields.every((e) => typeof e == "string") && s.add(c(t.fields));
+	}
+	for (let [t, n] of Object.entries(e.fields)) {
+		if (n.type !== "reference" || n.fkAutoIndex === !1 || s.has(c([t]))) continue;
+		let r = `${e.tableName}_${t}_idx`;
+		a.push(d(r, e.tableName, [t])), s.add(c([t]));
+	}
+	return a.join("\n");
+}, xe = "CREATE OR REPLACE FUNCTION framework_notify_change() RETURNS trigger AS $$\nDECLARE\n  payload TEXT;\nBEGIN\n  payload := json_build_object(\n    'table',  TG_TABLE_NAME,\n    -- The schema the write landed in. Under namespace isolation this is\n    -- the tenant schema (tenant_<id>); the CDC consumer uses it so a\n    -- write in tenant A namespace does not spuriously wake tenant B\n    -- subscriptions on the same-named table. public/absent = shared.\n    'schema', TG_TABLE_SCHEMA,\n    'op',     lower(TG_OP),\n    'old',    CASE WHEN TG_OP = 'INSERT' THEN NULL ELSE row_to_json(OLD) END,\n    'new',    CASE WHEN TG_OP = 'DELETE' THEN NULL ELSE row_to_json(NEW) END\n  )::text;\n  -- pg_notify hard-caps the payload at 8000 bytes; a wide reactive row\n  -- (big text / json column) would otherwise abort the write itself.\n  -- Fall back to a body-less notice — the CDC consumer treats absent\n  -- old/new as \"all columns changed\" and re-queries, so correctness is\n  -- preserved; only the delta-diff fast path is skipped for that write.\n  IF octet_length(payload) >= 7999 THEN\n    payload := json_build_object(\n      'table',     TG_TABLE_NAME,\n      'schema',    TG_TABLE_SCHEMA,\n      'op',        lower(TG_OP),\n      'old',       NULL,\n      'new',       NULL,\n      'oversized', true\n    )::text;\n  END IF;\n  PERFORM pg_notify('framework_changes', payload);\n  RETURN COALESCE(NEW, OLD);\nEND;\n$$ LANGUAGE plpgsql;", Se = (e) => `
+ALTER TABLE "${e.tableName}" REPLICA IDENTITY FULL;
+DROP TRIGGER IF EXISTS framework_changes_${e.tableName} ON "${e.tableName}";
+CREATE TRIGGER framework_changes_${e.tableName}
+AFTER INSERT OR UPDATE OR DELETE ON "${e.tableName}"
+FOR EACH ROW EXECUTE FUNCTION framework_notify_change();
+`.trim(), Ce = (e) => e.some((e) => Object.values(e.fields).some((e) => e.type === "vector")), we = (e) => e.some((e) => Object.values(e.fields).some((e) => e.spatial !== void 0)), Te = (e) => {
+	let t = new Map(e.map((e) => [e.tableName, e])), n = y(e.map((e) => e.tableName), (e) => {
+		let n = t.get(e);
+		return n ? Object.entries(n.fields).flatMap(([e, n]) => {
+			if (n.type !== "reference" || !n.references) return [];
+			let r = n.references().tableName;
+			return t.has(r) ? [{
+				column: e,
+				target: r
+			}] : [];
+		}) : [];
+	}), r = [];
+	for (let t of e) for (let [e, i] of Object.entries(t.fields)) i.type !== "reference" || !i.references || n.has(v(t.tableName, e)) && r.push({
+		table: t.tableName,
+		column: e,
+		targetTable: i.references().tableName,
+		onDelete: i.onDelete ?? "restrict",
+		onUpdate: i.refOnUpdate ?? "noAction"
+	});
+	let i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = [], s = (e) => {
+		if (!(i.has(e.tableName) || a.has(e.tableName))) {
+			a.add(e.tableName);
+			for (let [r, i] of Object.entries(e.fields)) {
+				if (i.type !== "reference" || !i.references || n.has(v(e.tableName, r))) continue;
+				let a = i.references();
+				if (a.tableName === e.tableName) continue;
+				let o = t.get(a.tableName);
+				o && s(o);
+			}
+			a.delete(e.tableName), i.add(e.tableName), o.push(e);
+		}
+	};
+	for (let t of e) s(t);
+	return {
+		sorted: o,
+		cyclic: r
+	};
+}, Ee = (e, n, r = null) => {
+	let i = (e) => r ? `${t(r, n)}.${t(e, n)}` : t(e, n), a = `${e.table}_${e.column}_fkey`, o = j(e.onDelete, n), s = j(e.onUpdate, n), c = ` ON DELETE ${o}${s === "NO ACTION" ? "" : ` ON UPDATE ${s}`}`, l = (r) => `ADD CONSTRAINT ${t(a, n)} FOREIGN KEY ${r ? "IF NOT EXISTS " : ""}(${t(e.column, n)}) REFERENCES ${i(e.targetTable)} (${t("id", n)})${c}`;
+	switch (n) {
+		case "postgres": return [
+			"DO $$ BEGIN",
+			"  IF NOT EXISTS (SELECT 1 FROM pg_constraint",
+			`    WHERE conname = '${a}' AND conrelid = '${r ? `${r}.` : ""}${e.table}'::regclass) THEN`,
+			`    ALTER TABLE ${i(e.table)} ${l(!1)};`,
+			"  END IF;",
+			"END $$;"
+		].join("\n");
+		case "mssql": return `IF NOT EXISTS (SELECT 1 FROM sys.foreign_keys WHERE name = '${a}') ALTER TABLE ${i(e.table)} ${l(!1)};`;
+		case "mariadb": return `ALTER TABLE ${i(e.table)} ${l(!0)};`;
+		default: return `ALTER TABLE ${i(e.table)} ${l(!1)};`;
+	}
+}, De = (t, n) => {
+	let r = /* @__PURE__ */ new Map();
+	if (e(n)) return r;
+	for (let e of t) {
+		let t = r.get(e.table) ?? /* @__PURE__ */ new Set();
+		t.add(e.column), r.set(e.table, t);
+	}
+	return r;
+}, Oe = (e, t) => {
+	if (t !== "postgres") return "";
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) for (let e of Object.values(t.fields)) {
+		if (e.type !== "enum" || !e.enumName || !e.enumValues) continue;
+		let t = n.get(e.enumName);
+		if (t && t.length !== e.enumValues.length) throw Error(`dbEnum '${e.enumName}' declared with conflicting value sets across tables. Define it once and re-use the handle.`);
+		n.set(e.enumName, e.enumValues);
+	}
+	if (n.size === 0) return "";
+	let r = [];
+	for (let [e, t] of n) {
+		let n = t.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		r.push(`DO $$ BEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = '${e.replace(/'/g, "''")}') THEN\n    CREATE TYPE "${e}" AS ENUM (${n});\n  END IF;\nEND $$;`);
+	}
+	return r.join("\n\n");
+}, ke = (e, t) => {
+	if (t !== "postgres") return "";
+	let n = /* @__PURE__ */ new Set();
+	for (let t of e) for (let e of Object.values(t.fields)) e.type === "enum" && e.enumName && n.add(e.enumName);
+	let r = [];
+	for (let e of n) for (let { from: t, to: n } of c(e)) {
+		let i = e.replace(/'/g, "''"), a = t.replace(/'/g, "''"), o = n.replace(/'/g, "''");
+		r.push(`DO \$\$
+DECLARE
+  type_oid oid;
+BEGIN
+  SELECT oid INTO type_oid FROM pg_type WHERE typname = '${i}';\n  IF type_oid IS NOT NULL\n     AND EXISTS (SELECT 1 FROM pg_enum WHERE enumtypid = type_oid AND enumlabel = '${a}')\n     AND NOT EXISTS (SELECT 1 FROM pg_enum WHERE enumtypid = type_oid AND enumlabel = '${o}') THEN\n    IF current_setting('server_version_num')::int >= 140000 THEN\n      EXECUTE format('ALTER TYPE %I RENAME VALUE %L TO %L', '${i}', '${a}', '${o}');\n    ELSE\n      UPDATE pg_enum SET enumlabel = '${o}' WHERE enumtypid = type_oid AND enumlabel = '${a}';\n    END IF;\n  END IF;\nEND $$;`);
+	}
+	return r.join("\n\n");
+}, Ae = (e) => {
+	let t = [], n = [];
+	for (let i of e) r(i) ? n.push(i) : t.push(i);
+	return {
+		tables: t,
+		views: n
+	};
+}, M = (t, n) => {
+	let { tables: r, views: a } = Ae(t), { sorted: o, cyclic: s } = Te(r), c = De(s, n), l = [];
+	n === "postgres" && Ce(o) && l.push("CREATE EXTENSION IF NOT EXISTS vector;"), n === "postgres" && we(o) && l.push("CREATE EXTENSION IF NOT EXISTS postgis;");
+	let u = ke(o, n);
+	u && l.push(u);
+	let d = Oe(o, n);
+	d && l.push(d);
+	for (let e of o) l.push(ve(e, n, null, c.get(e.tableName)));
+	if (!e(n)) for (let e of s) l.push(Ee(e, n));
+	for (let e of o) {
+		let t = be(e, n);
+		t && l.push(t);
+	}
+	let f = o.filter((e) => e.isReactive);
+	if (f.length > 0 && n === "postgres") {
+		l.push(xe);
+		for (let e of f) l.push(Se(e));
+	}
+	for (let e of a) l.push(i(e, n));
+	return l.join("\n\n") + "\n";
+}, je = (e, n, r) => {
+	let i = t(e, n);
+	switch (n) {
+		case "postgres": return `CREATE SCHEMA IF NOT EXISTS ${i};`;
+		case "mysql":
+		case "mariadb": return `CREATE DATABASE IF NOT EXISTS ${i};`;
+		case "mssql": return `IF SCHEMA_ID('${e.replace(/'/g, "''")}') IS NULL EXEC(N'CREATE SCHEMA ${i.replace(/'/g, "''")}');`;
+		case "turso":
+		case "sqlite": return `ATTACH DATABASE '${(r ?? `${e}.db`).replace(/'/g, "''")}' AS ${i};`;
+	}
+}, Me = (n, r, i, a) => {
+	let o = je(i, r, a), s = t(i, r);
+	if (r === "postgres") return `${o}\n\nSET search_path TO ${s};\n\n${M(n, r)}`;
+	if (r === "mysql" || r === "mariadb") return `${o}\n\nUSE ${s};\n\n${M(n, r)}`;
+	let { sorted: c, cyclic: l } = Te(n), u = De(l, r), d = [o];
+	for (let e of c) d.push(ve(e, r, i, u.get(e.tableName)));
+	if (!e(r)) for (let e of l) d.push(Ee(e, r, i));
+	for (let e of c) {
+		let t = be(e, r, i);
+		t && d.push(t);
+	}
+	return d.join("\n\n") + "\n";
+}, Ne = (e, n) => {
+	if (n !== "postgres") return M(e, n);
+	let { sorted: r, cyclic: i } = Te(e), a = De(i, n), o = [], s = ke(r, n);
+	s && o.push(s);
+	let c = Oe(r, n);
+	c && o.push(c);
+	for (let e of r) o.push(ve(e, n, null, a.get(e.tableName)));
+	for (let e of i) o.push(Ee(e, n));
+	for (let e of r) {
+		let r = Object.entries(e.fields);
+		if (r.length === 0) continue;
+		let i = r.map(([r, i]) => {
+			let o = _e(r, i, n, void 0, a.get(e.tableName)?.has(r) ?? !1);
+			return `ALTER TABLE ${t(e.tableName, n)} ADD COLUMN IF NOT EXISTS ${o};`;
+		});
+		o.push(i.join("\n"));
+	}
+	for (let e of r) {
+		let t = be(e, n);
+		t && o.push(t);
+	}
+	let l = r.filter((e) => e.isReactive);
+	if (l.length > 0) {
+		o.push(xe);
+		for (let e of l) o.push(Se(e));
+	}
+	return o.join("\n\n") + "\n";
+}, Pe = (e, t = "postgres") => d.gen(function* () {
+	let n = yield* p.SqlClient;
+	yield* E(n, Le(n, M(e, t), t)).pipe(d.orDie);
+}), Fe = (e, t) => {
+	let n = t.cause ?? {};
+	return (n.errno === 1061 || n.code === "ER_DUP_KEYNAME") && /^\s*CREATE\s+(UNIQUE\s+|FULLTEXT\s+)?INDEX\b/i.test(e);
+}, Ie = (e) => d.gen(function* () {
+	let t = yield* p.SqlClient;
+	for (let n of Re(e)) process.env.VOLTRO_MIGRATE_DEBUG === "1" && de.debug(`EXEC: ${n.replace(/\s+/g, " ").slice(0, 180)}`), yield* t.unsafe(n).pipe(d.catchIf((e) => Fe(n, e), () => d.void), d.tapError((e) => d.sync(() => {
+		de.error(_("migrate: statement failed", n, e, 200));
+	})), d.orDieWith((e) => Error(_("migrate: statement failed", n, e, 400).trim())));
+}), Le = (e, t, n) => (n === "turso" ? Ie(t) : e.withTransaction(Ie(t))).pipe(d.orDie), Re = (e) => {
+	let t = [], n = "", r = !1;
+	for (let i = 0; i < e.length; i++) {
+		if (e.slice(i, i + 2) === "$$") {
+			r = !r, n += "$$", i += 1;
+			continue;
+		}
+		let a = e[i];
+		if (a === ";" && !r) {
+			let e = n.trim();
+			e.length > 0 && t.push(e), n = "";
+		} else n += a;
+	}
+	let i = n.trim();
+	return i.length > 0 && t.push(i), t;
+}, ze = async (e, t, n = "postgres") => {
+	await d.runPromise(Pe(e, n).pipe(d.provide(t)));
+}, Be = (e, t, n = "postgres") => d.gen(function* () {
+	let r = Me(e, n, t), i = yield* p.SqlClient;
+	yield* E(i, Le(i, r, n)).pipe(d.orDie);
+}), Ve = async (e, t, n, r = "postgres") => {
+	await d.runPromise(Be(e, t, r).pipe(d.provide(n)));
+}, He = async (e, t, n = "postgres") => {
+	await d.runPromise(d.gen(function* () {
+		let t = Ne(e, n), r = yield* p.SqlClient;
+		yield* E(r, Le(r, t, n)).pipe(d.orDie);
+	}).pipe(d.provide(t)));
+}, Ue = (e) => {
+	if (e == null) return e;
+	if (Array.isArray(e)) return e.map(Ue);
+	if (typeof e != "object") return e;
+	let t = {};
+	for (let n of Object.keys(e).sort()) {
+		let r = e[n];
+		r !== void 0 && (t[n] = Ue(r));
+	}
+	return t;
+}, We = (e) => {
+	if (!e.idScheme) return e;
+	let { idScheme: t, ...n } = e;
+	return n;
+}, Ge = (e) => [...e].map(We).sort((e, t) => e.name.localeCompare(t.name)), Ke = (e) => [...e].sort((e, t) => e.name.localeCompare(t.name)), qe = (e) => [...e].map((e) => ({
+	name: e.name,
+	columns: Ge(e.columns),
+	indexes: Ke(e.indexes)
+})).sort((e, t) => e.name.localeCompare(t.name)), N = (e) => {
+	let t = { tables: qe(e.tables) }, n = JSON.stringify(Ue(t));
+	return m("sha256").update(n).digest("hex");
+}, P = (e) => e.slice(0, 16), Je = (e, t) => {
+	let n = t.references ? {
+		table: t.references().tableName,
+		column: "id",
+		...t.onDelete ? { onDelete: t.onDelete } : {},
+		...t.refOnUpdate ? { onUpdate: t.refOnUpdate } : {},
+		...t.orphanPolicy ? { orphanPolicy: t.orphanPolicy } : {}
+	} : void 0;
+	return {
+		name: e,
+		type: t.type,
+		nullable: t.generatedAs ? !0 : t.nullable,
+		unique: t.unique,
+		hasDefault: t.hasDefault,
+		...t.hasDefault && t.defaultValue !== void 0 ? { defaultValue: t.defaultValue } : {},
+		...n ? { references: n } : {},
+		...t.oneOf && t.oneOf.length > 0 ? { oneOf: t.oneOf } : {},
+		...t.idScheme ? { idScheme: { kind: t.idScheme.kind } } : {},
+		...t.rawDdl === void 0 ? {} : { rawDdl: t.rawDdl },
+		...t.precision === void 0 ? {} : { precision: t.precision },
+		...t.scale === void 0 ? {} : { scale: t.scale },
+		...t.generatedAs ? { generatedAs: {
+			expr: t.generatedAs.expr,
+			stored: t.generatedAs.stored
+		} } : {},
+		...t.narrowedFrom ? { narrowedFrom: {
+			from: t.narrowedFrom.from,
+			...t.narrowedFrom.using === void 0 ? {} : { using: t.narrowedFrom.using }
+		} } : {},
+		...t.sensitive ? { sensitive: t.sensitive } : t.encrypted && !t.safe ? { sensitive: { class: "secret" } } : {},
+		...t.safe ? { safe: !0 } : {}
+	};
+}, Ye = (e) => {
+	let t = [], n = /* @__PURE__ */ new Set(), r = (e) => {
+		n.has(e.name) || (n.add(e.name), t.push(e));
+	}, i = e.appliedPrimaryKey ?? [];
+	i.length > 0 ? r({
+		name: `${e.tableName}_pkey`,
+		table: e.tableName,
+		columns: [...i],
+		unique: !0
+	}) : e.fields.id && r({
+		name: `${e.tableName}_pkey`,
+		table: e.tableName,
+		columns: ["id"],
+		unique: !0
+	});
+	let o = e.appliedIndexes ?? [];
+	for (let t of o) {
+		let n = t.fields.map((e) => typeof e == "string" ? e : "jsonPath" in e ? `(json:${e.jsonPath.column}->${e.jsonPath.path.join(".")}${e.jsonPath.numeric ? "::num" : ""})` : `(${e.expr})`), i = t.fields.some((e) => typeof e != "string");
+		r({
+			name: t.name,
+			table: e.tableName,
+			columns: n,
+			unique: !1,
+			...i ? { expression: !0 } : {}
+		});
+	}
+	let s = e.appliedUniques ?? [];
+	for (let t of s) t.fields.length < 2 || r({
+		name: t.name,
+		table: e.tableName,
+		columns: t.fields,
+		unique: !0
+	});
+	let c = /* @__PURE__ */ new Set();
+	for (let e of o) e.fields.every((e) => typeof e == "string") && c.add(e.fields.join("\0"));
+	for (let [t, n] of Object.entries(e.fields)) {
+		let i = n;
+		if (i.dropped || !i.references || i.fkAutoIndex === !1 || c.has(t)) continue;
+		let o = `${e.tableName}_${t}_idx`;
+		a(e.tableName, o, !0, [t]), r({
+			name: o,
+			table: e.tableName,
+			columns: [t],
+			unique: !1
+		});
+	}
+	return t;
+}, Xe = (e) => {
+	let t = new Set((e.appliedUniques ?? []).filter((e) => e.fields.length === 1).map((e) => e.fields[0])), n = [];
+	for (let [r, i] of Object.entries(e.fields)) {
+		if (i.dropped) continue;
+		let e = Je(r, i);
+		n.push(t.has(r) ? {
+			...e,
+			unique: !0
+		} : e);
+	}
+	let r = e.appliedPrimaryKey ?? [];
+	return {
+		name: e.tableName,
+		columns: n,
+		indexes: Ye(e),
+		...r.length > 0 ? { primaryKey: [...r] } : {}
+	};
+}, Ze = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) for (let e of n.indexes) {
+		let r = t.get(e.name);
+		if (r !== void 0 && r !== n.name) throw Error(`duplicate index name '${e.name}' across tables '${r}' and '${n.name}'. Index names must be unique per SCHEMA, not just per table — the DB creates only one, so the other never applies and 'db plan' re-emits it forever. Give each an explicit, table-prefixed name (e.g. '${n.name}_${e.name}').`);
+		t.set(e.name, n.name);
+	}
+}, F = (e) => {
+	let t = e.map(Xe);
+	return Ze(t), { tables: t };
+}, Qe = /* @__PURE__ */ new Set(["voltro_isr_cache"]), $e = (e) => Qe.has(e) || e.startsWith("_voltro_") || e.startsWith("_cloud_") || e.startsWith("cluster_"), et = {
+	postgres: !0,
+	mysql: !0,
+	mariadb: !0,
+	mssql: !0,
+	sqlite: !0
+}, tt = {
+	postgres: !0,
+	mysql: !1,
+	mariadb: !1,
+	mssql: !0,
+	sqlite: !0
+}, nt = (e) => {
+	switch (e) {
+		case "add-column":
+		case "drop-column":
+		case "rename-column":
+		case "alter-column-nullability":
+		case "alter-column-type":
+		case "add-foreign-key":
+		case "add-unique":
+		case "add-unique-composite":
+		case "add-check": return tt;
+		default: return et;
+	}
+}, rt = (e, t) => {
+	let n = new Map(t.tables.map((e) => [e.name, e]));
+	return new Map(e.map((e) => [e.tableName, {
+		table: e,
+		snapshot: n.get(e.tableName),
+		columnDefs: e.fields
+	}]));
+}, it = (e) => (t, n) => t.name === e ? -1 : n.name === e ? 1 : t.name.localeCompare(n.name), I = (e) => {
+	if (typeof e != "object" || !e) return JSON.stringify(e);
+	if (Array.isArray(e)) return `[${e.map(I).join(",")}]`;
+	let t = e;
+	return `{${Object.keys(t).sort().map((e) => `${JSON.stringify(e)}:${I(t[e])}`).join(",")}}`;
+}, at = (e) => {
+	if (!e.hasDefault || e.defaultValue === void 0 || e.defaultValue === null) return null;
+	let t = e.defaultValue;
+	if (typeof t == "boolean") return t ? "__BOOL_TRUE__" : "__BOOL_FALSE__";
+	if (typeof t == "number") return String(t);
+	if (typeof t != "string") return I(t);
+	let n = t.trim(), r = n.toLowerCase().replace(/\s+/g, "");
+	if (r === "now" || r === "now()" || /^current_timestamp(\(\d*\))?$/.test(r) || r === "sysutcdatetime()" || r === "sysdatetime()" || r === "getutcdate()" || r === "getdate()") return "__NOW__";
+	let i = n.replace(/::[a-zA-Z0-9_ "]+$/, "").trim(), a = /^'(.*)'$/.test(i) ? i.slice(1, -1).replace(/''/g, "'") : i, o = /^cast\(\s*(?:_\w+\s*)?\\?'(.*?)\\?'\s+as\s+json\s*\)$/i.exec(a);
+	if (o) try {
+		return I(JSON.parse(o[1]));
+	} catch {}
+	if (a.startsWith("{") || a.startsWith("[")) try {
+		return I(JSON.parse(a));
+	} catch {}
+	return /^-?\d+(\.\d+)?$/.test(a) ? String(Number(a)) : a;
+}, ot = (e, t) => {
+	let n = at(e), r = at(t);
+	if (n === r) return !0;
+	let i = (e) => e === "1" || e === "true" ? "__BOOL_TRUE__" : e === "0" || e === "false" ? "__BOOL_FALSE__" : e;
+	return i(n) === i(r);
+}, L = (e) => {
+	if (!e) return null;
+	let t = (e) => e === "restrict" ? "noAction" : e;
+	return {
+		table: e.table,
+		column: e.column,
+		onDelete: t(e.onDelete),
+		onUpdate: t(e.onUpdate)
+	};
+}, st = (e, t) => {
+	let n = e && e.length > 0 ? e : void 0, r = t && t.length > 0 ? t : void 0;
+	if (!n && !r) return !0;
+	if (!n || !r || n.length !== r.length) return !1;
+	let i = [...n].sort(), a = [...r].sort();
+	return i.every((e, t) => e === a[t]);
+}, ct = (e, t) => e.type === t.type && e.nullable === t.nullable && e.unique === t.unique && ot(e, t) && JSON.stringify(L(e.references)) === JSON.stringify(L(t.references)) && st(e.oneOf, t.oneOf), lt = (e, t) => t.oneOf && t.oneOf.length > 0 ? R({
+	kind: "add-check",
+	table: e,
+	column: t.name,
+	values: t.oneOf
+}, "safe", `enum-membership CHECK on ${e}.${t.name}`) : void 0, ut = (e, t) => e.unique === t.unique && (e.expression || t.expression ? !0 : e.columns.length === t.columns.length && e.columns.every((e, n) => e === t.columns[n])), dt = (e, t) => {
+	let n = new Map(t.columns.map((e) => [e.name, e])), r = new Map(e.columns.map((e) => [e.name, e])), i = [], a = [], o = [];
+	for (let t of e.columns) {
+		let e = n.get(t.name);
+		if (!e) {
+			i.push(t);
+			continue;
+		}
+		ct(t, e) || o.push({
+			declared: t,
+			live: e
+		});
+	}
+	for (let e of t.columns) r.has(e.name) || a.push(e);
+	return {
+		added: i,
+		removed: a,
+		changed: o
+	};
+}, ft = (e, t) => {
+	let n = new Map(t.indexes.map((e) => [e.name, e])), r = new Map(e.indexes.map((e) => [e.name, e])), i = [], a = [];
+	for (let t of e.indexes) {
+		let e = n.get(t.name);
+		(!e || !ut(t, e)) && i.push(t);
+	}
+	for (let e of t.indexes) r.has(e.name) || a.push(e);
+	return {
+		added: i,
+		removed: a
+	};
+}, R = (e, t, n, r) => ({
+	op: e,
+	classification: t,
+	atomicByDialect: nt(e.kind),
+	...n ? { reason: n } : {},
+	...r ? { blocked: r } : {}
+}), pt = (e, t, n) => {
+	let r = {
+		kind: "add-column",
+		table: e,
+		column: t
+	};
+	return t.nullable ? R(r, "safe", "nullable column add — no backfill needed") : t.hasDefault && t.defaultValue !== void 0 ? R(r, "needs-default", "NOT NULL with literal default — DDL DEFAULT will populate existing rows") : n?.backfill ? R(r, "needs-backfill", `backfill declared (kind=${n.backfill.kind}) — applier will run 3-step add/update/set-not-null`) : R(r, "needs-backfill", "NOT NULL column on a table whose row count is unknown", { fix: `declare \`${t.name}: <type>().backfill(sql\`...\`)\` OR \`.default(value)\` so existing rows survive the migration` });
+}, mt = (e, t, n) => {
+	let r = {
+		kind: "drop-column",
+		table: e,
+		column: t.name
+	};
+	return n?.dropped ? R(r, "lossy", `column dropped via \`${t.name}: dropped()\` marker — intentional`) : R(r, "lossy", "column missing from declared schema", { fix: `if intentional, add \`${t.name}: dropped()\` to the schema. If a typo, restore the field` });
+}, ht = (e, t, n, r) => R({
+	kind: "create-table",
+	table: e,
+	columns: t,
+	indexes: n,
+	...r && r.length > 0 ? { primaryKey: r } : {}
+}, "safe", "new table — no data to preserve"), gt = (e) => R({
+	kind: "drop-table",
+	table: e
+}, "lossy", "table missing from declared schema", { fix: "if intentional, set VOLTRO_DESTRUCTIVE_OK=1 OR add a file-based migration. If a typo, restore the table declaration" }), _t = 5e4, vt = (e, t, n, r) => {
+	let i = (n ?? 0) >= r, a;
+	return a = t.unique ? t.columns.length === 1 ? {
+		kind: "add-unique",
+		table: e,
+		column: t.columns[0]
+	} : {
+		kind: "add-unique-composite",
+		table: e,
+		name: t.name,
+		fields: t.columns
+	} : {
+		kind: "add-index",
+		table: e,
+		index: t
+	}, i ? R(a, "online-required", `online build on ${n} rows — CONCURRENTLY / INPLACE / WITH(ONLINE=ON) depending on dialect`) : R(a, "safe", t.unique ? t.columns.length === 1 ? "add unique constraint" : "add composite UNIQUE constraint" : "add B-tree index");
+}, yt = (e, t) => t.unique && t.columns.length > 1 ? R({
+	kind: "drop-unique-composite",
+	table: e,
+	name: t.name
+}, "safe", "drop composite UNIQUE constraint (no data loss — constraint is derived metadata)") : R({
+	kind: "drop-index",
+	table: e,
+	index: t.name
+}, "safe", "drop index (no data loss — index is derived data)"), bt = (e, t) => {
+	if (e === "reference") return "text";
+	switch (t) {
+		case "sqlite":
+		case "turso": return e === "timestamp" || e === "date" || e === "json" ? "text" : e === "boolean" ? "integer" : e === "decimal" ? "text" : e === "bigint" ? "integer" : e;
+		case "mssql": return e === "json" ? "text" : e;
+		default: return e;
+	}
+}, xt = (e, t, n, r, i, a) => {
+	let o = [];
+	if (t.nullable !== n.nullable) {
+		let n = {
+			kind: "alter-column-nullability",
+			table: e,
+			column: t.name,
+			toNullable: t.nullable
+		};
+		o.push(t.nullable ? R(n, "safe", `loosen ${e}.${t.name} to nullable`) : R(n, "needs-backfill", `tighten ${e}.${t.name} to NOT NULL — existing rows must already be non-null`));
+	}
+	if (t.unique !== n.unique) if (t.unique) {
+		let n = {
+			kind: "add-unique",
+			table: e,
+			column: t.name
+		}, r = (i ?? 0) >= a;
+		o.push(r ? R(n, "online-required", `online unique build on ${i} rows — CONCURRENTLY / INPLACE / WITH(ONLINE=ON) depending on dialect`) : R(n, "safe", `add unique constraint on ${e}.${t.name} — existing rows must already be distinct (else the DB rejects at migrate)`));
+	} else o.push(R({
+		kind: "drop-unique",
+		table: e,
+		column: t.name
+	}, "safe", `drop unique constraint on ${e}.${t.name} — constraint is derived metadata, no data loss`));
+	if (bt(t.type, r) !== bt(n.type, r)) {
+		let r = t.narrowedFrom;
+		if (r && r.from === n.type) {
+			let i = {
+				kind: "alter-column-type",
+				table: e,
+				column: t.name,
+				from: n.type,
+				to: t.type,
+				...r.using === void 0 ? {} : { using: r.using }
+			};
+			o.push(R(i, "needs-backfill", `type change ${n.type} → ${t.type} on ${e}.${t.name} — narrowedFrom('${r.from}') declared` + (r.using ? ` with USING ${r.using}` : " (implicit cast)")));
+		} else {
+			let r = {
+				kind: "alter-column-type",
+				table: e,
+				column: t.name,
+				from: n.type,
+				to: t.type
+			};
+			o.push(R(r, "lossy", `type change ${n.type} → ${t.type} on ${e}.${t.name} may not be value-preserving`, { fix: `acknowledge it on the column: \`.narrowedFrom('${n.type}', { using: '${t.name}::${t.type}' })\` (drop \`using\` if the cast is implicit), or use a file-based migration` }));
+		}
+	}
+	if (!ot(t, n)) {
+		let n = {
+			kind: "alter-column-default",
+			table: e,
+			column: t.name,
+			hasDefault: t.hasDefault,
+			...t.defaultValue === void 0 ? {} : { defaultValue: t.defaultValue }
+		};
+		o.push(R(n, "safe", `default change on ${e}.${t.name} affects only future inserts`));
+	}
+	if (!st(t.oneOf, n.oneOf)) {
+		n.oneOf && n.oneOf.length > 0 && o.push(R({
+			kind: "drop-check",
+			table: e,
+			column: t.name
+		}, "safe", `drop stale enum CHECK on ${e}.${t.name}`));
+		let r = lt(e, t);
+		r && o.push(r);
+	}
+	if (JSON.stringify(L(t.references)) !== JSON.stringify(L(n.references)) && (n.references && o.push(R({
+		kind: "drop-foreign-key",
+		table: e,
+		column: t.name
+	}, "safe", `drop FK on ${e}.${t.name} (→ ${n.references.table})`)), t.references)) {
+		let n = t.references.table, r = t.references.orphanPolicy ?? "fail", i = {
+			kind: "add-foreign-key",
+			table: e,
+			column: t.name,
+			targetTable: n,
+			targetColumn: t.references.column,
+			...t.references.onDelete ? { onDelete: t.references.onDelete } : {},
+			...t.references.onUpdate ? { onUpdate: t.references.onUpdate } : {}
+		};
+		r === "null" && !t.nullable ? o.push(R(i, "lossy", `add FK ${e}.${t.name} → ${n}: orphanPolicy 'null' needs a nullable column (the NULL-out would violate NOT NULL)`, { fix: `make ${t.name} \`.nullable()\`, OR use \`orphanPolicy: 'delete'\`, OR clean the orphans and drop the policy` })) : r === "null" || r === "delete" ? o.push(R({
+			...i,
+			orphanPolicy: r
+		}, "lossy", r === "delete" ? `add FK ${e}.${t.name} → ${n}: orphanPolicy 'delete' first DELETES rows whose ${t.name} points at a missing ${n}` : `add FK ${e}.${t.name} → ${n}: orphanPolicy 'null' first NULLs ${t.name} where it points at a missing ${n}`)) : o.push(R(i, "needs-backfill", `add FK ${e}.${t.name} → ${n} — existing rows must already reference a valid ${n} (else set orphanPolicy:'null'/'delete')`));
+	}
+	return o;
+}, St = (e, t, n) => {
+	let r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = new Set(n.removed.map((e) => e.name)), s = new Set(n.added.map((e) => e.name));
+	for (let [n, c] of Object.entries(t)) {
+		let t = c.renamedFrom;
+		t && o.has(t) && s.has(n) && (i.add(n), a.add(t), r.push(R({
+			kind: "rename-column",
+			table: e.tableName,
+			from: t,
+			to: n
+		}, "safe", `rename via \`.renamedFrom('${t}')\``)));
+	}
+	return {
+		ops: r,
+		consumedAddedNames: i,
+		consumedRemovedNames: a
+	};
+}, Ct = (e) => {
+	let t = {
+		safe: 0,
+		needsDefault: 0,
+		needsBackfill: 0,
+		needsRenameAnnotation: 0,
+		lossy: 0,
+		onlineRequired: 0,
+		multiStep: 0,
+		blocked: 0
+	};
+	for (let n of e) switch (n.blocked && t.blocked++, n.classification) {
+		case "safe":
+			t.safe++;
+			break;
+		case "needs-default":
+			t.needsDefault++;
+			break;
+		case "needs-backfill":
+			t.needsBackfill++;
+			break;
+		case "needs-rename-annotation":
+			t.needsRenameAnnotation++;
+			break;
+		case "lossy":
+			t.lossy++;
+			break;
+		case "online-required":
+			t.onlineRequired++;
+			break;
+		case "multi-step":
+			t.multiStep++;
+			break;
+	}
+	return t;
+}, wt = (e) => {
+	let t = F(e.declared), n = rt(e.declared, t), r = new Map(e.live.tables.map((e) => [e.name, e])), i = e.onlineAfter ?? _t, a = [];
+	for (let e of t.tables) if (!r.has(e.name)) {
+		a.push(ht(e.name, e.columns, e.indexes, e.primaryKey));
+		for (let t of e.columns) {
+			let n = lt(e.name, t);
+			n && a.push(n);
+		}
+	}
+	let o = new Set(e.ignoreTables ?? []);
+	for (let t of e.live.tables) n.has(t.name) || $e(t.name) || o.has(t.name) || a.push(gt(t.name));
+	for (let o of t.tables) {
+		let t = r.get(o.name);
+		if (!t) continue;
+		let s = n.get(o.name), c = dt(o, t), l = ft(o, t), u = St(s.table, s.columnDefs, c);
+		a.push(...u.ops);
+		for (let e of c.removed) {
+			if (u.consumedRemovedNames.has(e.name)) continue;
+			let t = s.columnDefs[e.name];
+			a.push(mt(o.name, e, t));
+		}
+		for (let e of c.added) {
+			if (u.consumedAddedNames.has(e.name)) continue;
+			let t = s.columnDefs[e.name];
+			a.push(pt(o.name, e, t));
+			let n = lt(o.name, e);
+			n && a.push(n);
+		}
+		for (let e of l.added) a.push(vt(o.name, e, t.rowCount, i));
+		for (let e of l.removed) a.push(yt(o.name, e));
+		for (let { declared: n, live: r } of c.changed) a.push(...xt(o.name, n, r, e.dialect, t.rowCount, i));
+	}
+	let s = new Set(a.flatMap((e) => e.op.kind === "create-table" ? [e.op.table] : [])), c = new Map(t.tables.map((e) => [e.name, e])), l = (e) => {
+		let t = c.get(e);
+		return t ? t.columns.flatMap((e) => e.references && s.has(e.references.table) ? [{
+			column: e.name,
+			target: e.references.table
+		}] : []) : [];
+	}, u = y([...s], l), d = [];
+	for (let e of t.tables) if (s.has(e.name)) for (let t of e.columns) !t.references || !u.has(v(e.name, t.name)) || d.push(R({
+		kind: "add-foreign-key",
+		table: e.name,
+		column: t.name,
+		targetTable: t.references.table,
+		targetColumn: t.references.column,
+		...t.references.onDelete ? { onDelete: t.references.onDelete } : {},
+		...t.references.onUpdate ? { onUpdate: t.references.onUpdate } : {}
+	}, "safe", `deferred FK ${e.name}.${t.name} → ${t.references.table} — breaks a create-time table cycle`));
+	if (u.size > 0) {
+		let e = (e) => e.references ? Object.fromEntries(Object.entries(e).filter(([e]) => e !== "references")) : e;
+		for (let t = 0; t < a.length; t += 1) {
+			let n = a[t];
+			if (n.op.kind !== "create-table") continue;
+			let r = n.op;
+			if (!r.columns.some((e) => u.has(v(r.table, e.name)))) continue;
+			let i = r.columns.map((t) => u.has(v(r.table, t.name)) ? e(t) : t);
+			a[t] = {
+				...n,
+				op: {
+					...r,
+					columns: i
+				}
+			};
+		}
+		a.push(...d);
+	}
+	let f = new Map(t.tables.map((e) => [e.name, e])), p = /* @__PURE__ */ new Map(), m = (e, t = /* @__PURE__ */ new Set()) => {
+		let n = p.get(e);
+		if (n !== void 0) return n;
+		if (t.has(e)) return 0;
+		let r = f.get(e);
+		if (!r) return 0;
+		let i = new Set(t).add(e), a = 0;
+		for (let t of r.columns) {
+			let n = t.references?.table;
+			n && n !== e && !u.has(v(e, t.name)) && (a = Math.max(a, m(n, i) + 1));
+		}
+		return p.set(e, a), a;
+	}, h = (e) => e === "create-table" ? 0 : e === "drop-table" ? 2 : 1, g = (e) => {
+		let t = "table" in e ? e.table : "";
+		return e.kind === "create-table" ? m(t) : e.kind === "drop-table" ? -m(t) : 0;
+	}, ee = {
+		"add-column": 0,
+		"rename-column": 1,
+		"alter-column-nullability": 2,
+		"alter-column-type": 2,
+		"alter-column-default": 2,
+		"drop-index": 3,
+		"drop-check": 3,
+		"drop-unique": 3,
+		"drop-unique-composite": 3,
+		"drop-foreign-key": 3,
+		"drop-column": 4,
+		"add-index": 5,
+		"add-unique": 5,
+		"add-unique-composite": 5,
+		"add-foreign-key": 5,
+		"add-check": 5
+	}, _ = (e) => ee[e] ?? 9, b = [...a].sort((e, t) => {
+		let n = h(e.op.kind), r = h(t.op.kind);
+		if (n !== r) return n - r;
+		let i = g(e.op), a = g(t.op);
+		if (i !== a) return i - a;
+		let o = "table" in e.op ? e.op.table : "", s = "table" in t.op ? t.op.table : "";
+		if (o !== s) return o.localeCompare(s);
+		let c = _(e.op.kind), l = _(t.op.kind);
+		return c === l ? e.op.kind.localeCompare(t.op.kind) : c - l;
+	});
+	return {
+		operations: b,
+		fromFingerprint: N(e.live),
+		toFingerprint: N(t),
+		summary: Ct(b)
+	};
+}, Tt = (e) => {
+	let t = /[`"[]?([A-Za-z_][A-Za-z0-9_]*)[`"\]]?\s*(?:in\b|=)/i.exec(e);
+	if (!t) return null;
+	let n = [...e.matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'"));
+	return n.length === 0 ? null : {
+		column: t[1],
+		values: n
+	};
+}, Et = (e, t) => {
+	if (t === "vector") return "vector";
+	switch (e) {
+		case "text":
+		case "character varying":
+		case "varchar":
+		case "uuid":
+		case "character": return "text";
+		case "integer":
+		case "smallint": return "integer";
+		case "bigint": return "bigint";
+		case "double precision":
+		case "real": return "real";
+		case "numeric":
+		case "decimal": return "decimal";
+		case "boolean": return "boolean";
+		case "bytea": return "bytes";
+		case "timestamp without time zone":
+		case "timestamp with time zone":
+		case "timestamptz":
+		case "timestamp": return "timestamp";
+		case "date": return "date";
+		case "json":
+		case "jsonb": return "json";
+		case "USER-DEFINED": return "text";
+		default: return "text";
+	}
+}, z = (e) => {
+	switch (e.toUpperCase()) {
+		case "CASCADE": return "cascade";
+		case "RESTRICT": return "restrict";
+		case "SET NULL": return "setNull";
+		case "SET DEFAULT": return "noAction";
+		default: return "noAction";
+	}
+}, Dt = (e, t) => {
+	let n = e !== void 0 && e !== "" ? Number(e) : NaN;
+	return Number.isInteger(n) && n > 0 ? n : t;
+}, Ot = () => Dt(process.env.VOLTRO_INTROSPECT_BATCH, 20), kt = 300, At = () => {
+	let e = process.env.VOLTRO_INTROSPECT_TIMEOUT_MS;
+	return e !== void 0 && e.trim() === "0" ? 0 : Dt(e, 3e4);
+}, jt = (e, t) => {
+	let n = Number.isFinite(t) && t >= 1 ? Math.floor(t) : 1, r = [];
+	for (let t = 0; t < e.length; t += n) r.push(e.slice(t, t + n));
+	return r;
+}, Mt = (e) => {
+	let t = At(), n = d.gen(function* () {
+		t > 0 && (yield* e.unsafe(`SET LOCAL statement_timeout = ${t}`));
+		let n = (t) => e.unsafe("(" + t.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ") + ")"), r = (t) => e.unsafe(String(Math.max(0, Math.trunc(t)))), i = Ot(), a = (e, t) => d.gen(function* () {
+			let r = [];
+			for (let a of jt(e, i)) a.length !== 0 && r.push(...yield* t(n(a)));
+			return r;
+		}), o = [];
+		for (let t = 0;; t += kt) {
+			let n = yield* e`
+        SELECT c.relname AS table_name,
+               COALESCE(c.reltuples::bigint, 0) AS row_count
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = current_schema() AND c.relkind = 'r'
+        ORDER BY c.relname
+        LIMIT ${r(kt)} OFFSET ${r(t)}
+      `;
+			if (o.push(...n), n.length < kt) break;
+		}
+		let s = /* @__PURE__ */ new Set(), c = [];
+		for (let e of o) s.has(e.table_name) || (s.add(e.table_name), c.push(e));
+		let l = c.map((e) => e.table_name), u = yield* a(l, (t) => e`
+      SELECT table_name, column_name, data_type, udt_name, is_nullable, column_default
+      FROM information_schema.columns
+      WHERE table_schema = current_schema() AND table_name IN ${t}
+      ORDER BY table_name, ordinal_position
+    `), f = yield* a(l, (t) => e`
+      SELECT rel.relname AS table_name, att.attname AS column_name
+      FROM pg_constraint con
+      JOIN pg_class     rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ANY (con.conkey)
+      WHERE con.contype = 'p' AND nsp.nspname = current_schema()
+        AND rel.relname IN ${t}
+    `), p = yield* a(l, (t) => e`
+      SELECT rel.relname AS table_name, con.conname AS constraint_name,
+             att.attname AS column_name, array_position(con.conkey, att.attnum) AS position
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = ANY (con.conkey)
+      WHERE con.contype = 'u' AND nsp.nspname = current_schema() AND rel.relname IN ${t}
+    `), m = yield* a(l, (t) => e`
+      SELECT rel.relname AS table_name, att.attname AS column_name, pg_get_constraintdef(con.oid) AS def
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = con.conkey[1]
+      WHERE con.contype = 'c' AND nsp.nspname = current_schema() AND array_length(con.conkey, 1) = 1
+        AND rel.relname IN ${t}
+    `), h = /* @__PURE__ */ new Map();
+		for (let e of m) {
+			let t = [...e.def.matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'"));
+			t.length > 0 && h.set(`${e.table_name}.${e.column_name}`, t);
+		}
+		let g = yield* a(l, (t) => e`
+      SELECT
+        rel.relname   AS source_table,
+        att.attname   AS source_column,
+        frel.relname  AS target_table,
+        fatt.attname  AS target_column,
+        CASE con.confdeltype
+          WHEN 'c' THEN 'CASCADE' WHEN 'r' THEN 'RESTRICT'
+          WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT'
+          ELSE 'NO ACTION' END AS delete_rule,
+        CASE con.confupdtype
+          WHEN 'c' THEN 'CASCADE' WHEN 'r' THEN 'RESTRICT'
+          WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT'
+          ELSE 'NO ACTION' END AS update_rule
+      FROM pg_constraint con
+      JOIN pg_class     rel  ON rel.oid  = con.conrelid
+      JOIN pg_class     frel ON frel.oid = con.confrelid
+      JOIN pg_namespace nsp  ON nsp.oid  = rel.relnamespace
+      JOIN unnest(con.conkey)  WITH ORDINALITY AS ck(attnum, ord) ON true
+      JOIN unnest(con.confkey) WITH ORDINALITY AS fk(attnum, ord) ON fk.ord = ck.ord
+      JOIN pg_attribute att  ON att.attrelid  = con.conrelid  AND att.attnum  = ck.attnum
+      JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = fk.attnum
+      WHERE con.contype = 'f' AND nsp.nspname = current_schema()
+        AND rel.relname IN ${t}
+      ORDER BY rel.relname, con.conname, ck.ord
+    `), ee = yield* a(l, (t) => e`
+      WITH ix AS (
+        SELECT
+          c.relname AS table_name,
+          i.relname AS index_name,
+          ix2.indisunique AS is_unique,
+          (0 = ANY (ix2.indkey::int[])) AS has_expression,
+          a.attname AS column_name,
+          array_position(ix2.indkey::int[], a.attnum) + 1 AS position
+        FROM pg_index ix2
+        JOIN pg_class i ON i.oid = ix2.indexrelid
+        JOIN pg_class c ON c.oid = ix2.indrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY (ix2.indkey)
+        LEFT JOIN pg_constraint con ON con.conindid = i.oid
+        WHERE n.nspname = current_schema()
+          AND NOT ix2.indisprimary
+          AND con.conindid IS NULL
+          AND c.relname IN ${t}
+      )
+      SELECT * FROM ix ORDER BY table_name, index_name, position
+    `), _ = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map();
+		for (let e of u) {
+			let t = _.get(e.table_name);
+			t || (t = [], _.set(e.table_name, t)), t.push(e);
+		}
+		for (let e of f) {
+			let t = v.get(e.table_name);
+			t || (t = /* @__PURE__ */ new Set(), v.set(e.table_name, t)), t.add(e.column_name);
+		}
+		let C = /* @__PURE__ */ new Map();
+		for (let e of p) {
+			let t = `${e.table_name}${e.constraint_name}`, n = C.get(t);
+			n || (n = {
+				table: e.table_name,
+				columns: []
+			}, C.set(t, n)), n.columns.push({
+				name: e.column_name,
+				position: e.position
+			});
+		}
+		for (let [e, t] of C) {
+			let n = [...t.columns].sort((e, t) => e.position - t.position).map((e) => e.name);
+			if (n.length === 1) {
+				let e = y.get(t.table);
+				e || (e = /* @__PURE__ */ new Set(), y.set(t.table, e)), e.add(n[0]);
+			} else {
+				let r = b.get(t.table);
+				r || (r = [], b.set(t.table, r)), r.push({
+					name: e.slice(e.indexOf("\0") + 1),
+					table: t.table,
+					columns: n,
+					unique: !0
+				});
+			}
+		}
+		for (let e of g) {
+			let t = x.get(e.source_table);
+			t || (t = [], x.set(e.source_table, t)), t.push(e);
+		}
+		for (let e of ee) {
+			let t = S.get(e.table_name);
+			t || (t = /* @__PURE__ */ new Map(), S.set(e.table_name, t));
+			let n = t.get(e.index_name);
+			n || (n = [], t.set(e.index_name, n)), n.push(e);
+		}
+		let te = [];
+		for (let e of c) {
+			let t = /* @__PURE__ */ new Set(), n = (_.get(e.table_name) ?? []).filter((e) => t.has(e.column_name) ? !1 : (t.add(e.column_name), !0)), r = v.get(e.table_name) ?? /* @__PURE__ */ new Set(), i = y.get(e.table_name) ?? /* @__PURE__ */ new Set(), a = x.get(e.table_name) ?? [], o = new Map(a.map((e) => [e.source_column, e])), s = new Set(n.filter((e) => e.udt_name === "tsvector").map((e) => e.column_name)), c = n.filter((e) => !s.has(e.column_name)).map((t) => {
+				let n = r.has(t.column_name) && r.size === 1, a = o.get(t.column_name), s = a ? "reference" : n && t.column_name === "id" ? "id" : Et(t.data_type, t.udt_name), c = a ? {
+					table: a.target_table,
+					column: a.target_column,
+					onDelete: z(a.delete_rule),
+					onUpdate: z(a.update_rule)
+				} : void 0, l = h.get(`${e.table_name}.${t.column_name}`);
+				return {
+					name: t.column_name,
+					type: s,
+					nullable: t.is_nullable === "YES",
+					unique: i.has(t.column_name) || n && t.column_name === "id",
+					hasDefault: t.column_default !== null,
+					...t.column_default === null ? {} : { defaultValue: t.column_default },
+					...c ? { references: c } : {},
+					...l ? { oneOf: l } : {}
+				};
+			}), l = [], u = S.get(e.table_name);
+			if (u) for (let [t, n] of u) {
+				let r = /* @__PURE__ */ new Set(), i = [...n].filter((e) => e.column_name !== null && e.position !== null).sort((e, t) => (e.position ?? 0) - (t.position ?? 0)).filter((e) => {
+					let t = e.position;
+					return r.has(t) ? !1 : (r.add(t), !0);
+				});
+				if (i.some((e) => s.has(e.column_name))) continue;
+				let a = n.some((e) => e.has_expression);
+				l.push({
+					name: t,
+					table: e.table_name,
+					columns: i.map((e) => e.column_name),
+					unique: n[0]?.is_unique ?? !1,
+					...a ? { expression: !0 } : {}
+				});
+			}
+			for (let t of b.get(e.table_name) ?? []) l.push(t);
+			r.size > 0 && l.push({
+				name: `${e.table_name}_pkey`,
+				table: e.table_name,
+				columns: [...r],
+				unique: !0
+			});
+			let d = Number(e.row_count ?? 0);
+			te.push({
+				name: e.table_name,
+				columns: c,
+				indexes: l,
+				...d > 0 ? { rowCount: d } : {}
+			});
+		}
+		return { tables: te };
+	});
+	return (t > 0 ? e.withTransaction(n) : n).pipe(d.catchAll((e) => {
+		let n = `${String(e)} ${String(e.cause ?? "")}`.toLowerCase();
+		return n.includes("statement timeout") || n.includes("57014") ? d.die(/* @__PURE__ */ Error(`schema introspection exceeded VOLTRO_INTROSPECT_TIMEOUT_MS (${t}ms) — the schema is very large / FK-dense or the database is slow. Raise VOLTRO_INTROSPECT_TIMEOUT_MS, set it to 0 to disable the ceiling, or use DB_DIRECT_URL for a non-pooler connection.`)) : d.fail(e);
+	}));
+}, Nt = (e, t) => {
+	switch (e.toLowerCase()) {
+		case "varchar":
+		case "char":
+		case "text":
+		case "tinytext":
+		case "mediumtext":
+		case "longtext":
+		case "enum": return "text";
+		case "tinyint": return t.toLowerCase() === "tinyint(1)" ? "boolean" : "integer";
+		case "int":
+		case "integer":
+		case "smallint":
+		case "mediumint": return "integer";
+		case "bigint": return "bigint";
+		case "decimal":
+		case "numeric": return "decimal";
+		case "double":
+		case "float":
+		case "real": return "real";
+		case "datetime":
+		case "timestamp": return "timestamp";
+		case "date": return "date";
+		case "blob":
+		case "tinyblob":
+		case "mediumblob":
+		case "longblob":
+		case "binary":
+		case "varbinary": return "bytes";
+		case "json": return "json";
+		default: return "text";
+	}
+}, B = (e) => e.map((e) => {
+	let t = e, n = {};
+	for (let e of Object.keys(t)) n[e.toLowerCase()] = t[e];
+	return n;
+}), Pt = (e) => d.gen(function* () {
+	let t = B(yield* e`
+      SELECT table_name, COALESCE(table_rows, 0) AS table_rows
+      FROM information_schema.tables
+      WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
+      ORDER BY table_name`), n = B(yield* e`
+      SELECT table_name, column_name, data_type, column_type, is_nullable, column_default, column_key
+      FROM information_schema.columns
+      WHERE table_schema = DATABASE()
+      ORDER BY table_name, ordinal_position`), r = B(yield* e`
+      SELECT k.table_name              AS source_table,
+             k.column_name             AS source_column,
+             k.referenced_table_name   AS target_table,
+             k.referenced_column_name  AS target_column,
+             r.delete_rule, r.update_rule
+      FROM information_schema.key_column_usage k
+      JOIN information_schema.referential_constraints r
+        ON k.constraint_name = r.constraint_name
+       AND k.table_schema    = r.constraint_schema
+      WHERE k.table_schema = DATABASE() AND k.referenced_table_name IS NOT NULL`), i = B(yield* e`
+      SELECT table_name, index_name, non_unique, column_name, seq_in_index
+      FROM information_schema.statistics
+      WHERE table_schema = DATABASE() AND index_name <> 'PRIMARY'
+      ORDER BY table_name, index_name, seq_in_index`), a = B(yield* e`
+      SELECT table_name, check_clause
+      FROM information_schema.check_constraints
+      WHERE constraint_schema = DATABASE()`.unprepared.pipe(d.orElseSucceed(() => []))), o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map();
+	for (let e of a) {
+		let t = /json_valid\(`?([^`)]+)`?\)/i.exec(e.check_clause);
+		if (t) {
+			o.add(`${e.table_name}.${t[1]}`);
+			continue;
+		}
+		let n = Tt(e.check_clause);
+		n && s.set(`${e.table_name}.${n.column}`, n.values);
+	}
+	let c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		let t = c.get(e.table_name) ?? [];
+		t.push(e), c.set(e.table_name, t);
+	}
+	for (let e of r) {
+		let t = l.get(e.source_table) ?? [];
+		t.push(e), l.set(e.source_table, t);
+	}
+	for (let e of i) {
+		let t = u.get(e.table_name);
+		t || (t = /* @__PURE__ */ new Map(), u.set(e.table_name, t));
+		let n = t.get(e.index_name) ?? [];
+		n.push(e), t.set(e.index_name, n);
+	}
+	let f = [];
+	for (let e of t) {
+		let t = c.get(e.table_name) ?? [], n = l.get(e.table_name) ?? [], r = new Map(n.map((e) => [e.source_column, e])), i = t.filter((e) => e.column_key === "PRI").map((e) => e.column_name), a = /* @__PURE__ */ new Set(), d = u.get(e.table_name);
+		if (d) for (let e of d.values()) e.length === 1 && e[0].non_unique === 0 && a.add(e[0].column_name);
+		let p = t.map((t) => {
+			let n = i.includes(t.column_name) && i.length === 1, c = r.get(t.column_name), l = c ? "reference" : n && t.column_name === "id" ? "id" : o.has(`${e.table_name}.${t.column_name}`) ? "json" : Nt(t.data_type, t.column_type), u = c ? {
+				table: c.target_table,
+				column: c.target_column,
+				onDelete: z(c.delete_rule),
+				onUpdate: z(c.update_rule)
+			} : void 0, d = a.has(t.column_name) || n && t.column_name === "id", f = t.column_default === "NULL" ? null : t.column_default, p = s.get(`${e.table_name}.${t.column_name}`);
+			return {
+				name: t.column_name,
+				type: l,
+				nullable: t.is_nullable === "YES",
+				unique: d,
+				hasDefault: f !== null,
+				...f === null ? {} : { defaultValue: f },
+				...u ? { references: u } : {},
+				...p ? { oneOf: p } : {}
+			};
+		}), m = new Set(n.map((e) => e.source_column)), h = [];
+		if (d) for (let [t, n] of d) {
+			let r = [...n].sort((e, t) => e.seq_in_index - t.seq_in_index);
+			r.length === 1 && r[0].non_unique === 0 || r.length === 1 && r[0].non_unique !== 0 && m.has(r[0].column_name) && t !== `${e.table_name}_${r[0].column_name}_idx` || h.push({
+				name: t,
+				table: e.table_name,
+				columns: r.map((e) => e.column_name),
+				unique: r[0].non_unique === 0
+			});
+		}
+		i.length > 0 && h.push({
+			name: `${e.table_name}_pkey`,
+			table: e.table_name,
+			columns: i,
+			unique: !0
+		});
+		let g = Number(e.table_rows ?? 0);
+		f.push({
+			name: e.table_name,
+			columns: p,
+			indexes: h,
+			...g > 0 ? { rowCount: g } : {}
+		});
+	}
+	return { tables: f };
+}), Ft = (e) => {
+	let t = e.toUpperCase();
+	return t.includes("INT") ? "integer" : t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB") ? "real" : t.includes("BLOB") ? "bytes" : "text";
+}, It = (e) => d.gen(function* () {
+	let t = yield* e`
+      SELECT name, sql FROM sqlite_master
+      WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+      ORDER BY name`, n = (e) => `'${e.replace(/'/g, "''")}'`, r = [];
+	for (let { name: i, sql: a } of t) {
+		let t = /* @__PURE__ */ new Map();
+		for (let e of (a ?? "").matchAll(/CHECK\s*\(\s*"([^"]+)"\s+IN\s*\(([^)]*)\)/gi)) {
+			let n = [...e[2].matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'"));
+			n.length > 0 && t.set(e[1], n);
+		}
+		let o = yield* e.unsafe(`PRAGMA table_info(${n(i)})`), s = yield* e.unsafe(`PRAGMA foreign_key_list(${n(i)})`), c = yield* e.unsafe(`PRAGMA index_list(${n(i)})`), l = new Map(s.map((e) => [e.from, e])), u = o.filter((e) => e.pk > 0).sort((e, t) => e.pk - t.pk).map((e) => e.name), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set();
+		for (let t of c) {
+			let r = (yield* e.unsafe(`PRAGMA index_info(${n(t.name)})`)).map((e) => e.name).filter((e) => e !== null);
+			d.set(t.name, r), t.unique === 1 && r.length === 1 && f.add(r[0]);
+		}
+		let p = o.map((e) => {
+			let n = u.length === 1 && u[0] === e.name, r = l.get(e.name), i = r ? "reference" : n && e.name === "id" ? "id" : Ft(e.type), a = r ? {
+				table: r.table,
+				column: r.to,
+				onDelete: z(r.on_delete),
+				onUpdate: z(r.on_update)
+			} : void 0, o = t.get(e.name);
+			return {
+				name: e.name,
+				type: i,
+				nullable: e.notnull === 0,
+				unique: f.has(e.name) || n && e.name === "id",
+				hasDefault: e.dflt_value !== null,
+				...e.dflt_value === null ? {} : { defaultValue: e.dflt_value },
+				...a ? { references: a } : {},
+				...o ? { oneOf: o } : {}
+			};
+		}), m = new Set(s.map((e) => e.from)), h = [];
+		for (let e of c) {
+			if (e.origin === "pk") continue;
+			let t = d.get(e.name) ?? [];
+			t.length === 1 && e.unique === 1 || t.length === 1 && e.unique !== 1 && m.has(t[0]) && e.name !== `${i}_${t[0]}_idx` || h.push({
+				name: e.name,
+				table: i,
+				columns: t,
+				unique: e.unique === 1
+			});
+		}
+		u.length > 0 && h.push({
+			name: `${i}_pkey`,
+			table: i,
+			columns: u,
+			unique: !0
+		}), r.push({
+			name: i,
+			columns: p,
+			indexes: h
+		});
+	}
+	return { tables: r };
+}), Lt = (e) => {
+	switch (e.toLowerCase()) {
+		case "int":
+		case "smallint":
+		case "tinyint": return "integer";
+		case "bigint": return "bigint";
+		case "decimal":
+		case "numeric":
+		case "money": return "decimal";
+		case "float":
+		case "real": return "real";
+		case "bit": return "boolean";
+		case "datetime2":
+		case "datetime":
+		case "smalldatetime":
+		case "datetimeoffset": return "timestamp";
+		case "date": return "date";
+		case "varbinary":
+		case "binary":
+		case "image": return "bytes";
+		default: return "text";
+	}
+}, V = (e) => e === !0 || e === 1, Rt = (e) => d.gen(function* () {
+	let t = yield* e`
+      SELECT TABLE_NAME AS table_name FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME`, n = yield* e`
+      SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name, DATA_TYPE AS data_type,
+             IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default
+      FROM INFORMATION_SCHEMA.COLUMNS ORDER BY TABLE_NAME, ORDINAL_POSITION`, r = yield* e`
+      SELECT st.name AS source_table, sc.name AS source_column,
+             tt.name AS target_table, tc.name AS target_column,
+             fk.delete_referential_action_desc AS delete_rule,
+             fk.update_referential_action_desc AS update_rule
+      FROM sys.foreign_keys fk
+      JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
+      JOIN sys.tables  st ON st.object_id = fkc.parent_object_id
+      JOIN sys.columns sc ON sc.object_id = fkc.parent_object_id AND sc.column_id = fkc.parent_column_id
+      JOIN sys.tables  tt ON tt.object_id = fkc.referenced_object_id
+      JOIN sys.columns tc ON tc.object_id = fkc.referenced_object_id AND tc.column_id = fkc.referenced_column_id`, i = yield* e`
+      SELECT t.name AS table_name, i.name AS index_name, i.is_unique AS is_unique,
+             i.is_primary_key AS is_primary, c.name AS column_name, ic.key_ordinal AS key_ordinal
+      FROM sys.indexes i
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE i.type > 0 AND ic.is_included_column = 0
+      ORDER BY t.name, i.name, ic.key_ordinal`, a = yield* e`
+      SELECT t.name AS table_name, c.name AS column_name, cc.definition AS def
+      FROM sys.check_constraints cc
+      JOIN sys.tables t ON t.object_id = cc.parent_object_id
+      JOIN sys.columns c ON c.object_id = cc.parent_object_id AND c.column_id = cc.parent_column_id
+      WHERE cc.parent_column_id <> 0`, o = /* @__PURE__ */ new Map();
+	for (let e of a) {
+		let t = [...e.def.matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'"));
+		t.length > 0 && o.set(`${e.table_name}.${e.column_name}`, t);
+	}
+	let s = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		let t = s.get(e.table_name) ?? [];
+		t.push(e), s.set(e.table_name, t);
+	}
+	let c = /* @__PURE__ */ new Map();
+	for (let e of r) {
+		let t = c.get(e.source_table) ?? [];
+		t.push(e), c.set(e.source_table, t);
+	}
+	let l = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		let t = l.get(e.table_name);
+		t || (t = /* @__PURE__ */ new Map(), l.set(e.table_name, t));
+		let n = t.get(e.index_name) ?? [];
+		n.push(e), t.set(e.index_name, n);
+	}
+	let u = [];
+	for (let { table_name: e } of t) {
+		let t = s.get(e) ?? [], n = c.get(e) ?? [], r = new Map(n.map((e) => [e.source_column, e])), i = new Set(n.map((e) => e.source_column)), a = l.get(e), d = [], f = /* @__PURE__ */ new Set();
+		if (a) for (let [, e] of a) {
+			let t = [...e].sort((e, t) => e.key_ordinal - t.key_ordinal);
+			if (V(t[0].is_primary)) for (let e of t) d.push(e.column_name);
+			else V(t[0].is_unique) && t.length === 1 && f.add(t[0].column_name);
+		}
+		let p = t.map((t) => {
+			let n = d.length === 1 && d[0] === t.column_name, i = r.get(t.column_name), a = i ? "reference" : n && t.column_name === "id" ? "id" : Lt(t.data_type), s = i ? {
+				table: i.target_table,
+				column: i.target_column,
+				onDelete: zt(i.delete_rule),
+				onUpdate: zt(i.update_rule)
+			} : void 0, c = t.column_default === null ? null : Bt(t.column_default), l = o.get(`${e}.${t.column_name}`);
+			return {
+				name: t.column_name,
+				type: a,
+				nullable: t.is_nullable === "YES",
+				unique: f.has(t.column_name) || n && t.column_name === "id",
+				hasDefault: c !== null,
+				...c === null ? {} : { defaultValue: c },
+				...s ? { references: s } : {},
+				...l ? { oneOf: l } : {}
+			};
+		}), m = [];
+		if (a) for (let [t, n] of a) {
+			let r = [...n].sort((e, t) => e.key_ordinal - t.key_ordinal);
+			V(r[0].is_primary) || r.length === 1 && V(r[0].is_unique) || r.length === 1 && !V(r[0].is_unique) && i.has(r[0].column_name) && t !== `${e}_${r[0].column_name}_idx` || m.push({
+				name: t,
+				table: e,
+				columns: r.map((e) => e.column_name),
+				unique: V(r[0].is_unique)
+			});
+		}
+		d.length > 0 && m.push({
+			name: `${e}_pkey`,
+			table: e,
+			columns: d,
+			unique: !0
+		}), u.push({
+			name: e,
+			columns: p,
+			indexes: m
+		});
+	}
+	return { tables: u };
+}), zt = (e) => {
+	switch (e.toUpperCase().replace(/_/g, " ")) {
+		case "CASCADE": return "cascade";
+		case "SET NULL": return "setNull";
+		case "SET DEFAULT": return "noAction";
+		default: return "noAction";
+	}
+}, Bt = (e) => {
+	let t = e.trim();
+	for (; t.startsWith("(") && t.endsWith(")");) t = t.slice(1, -1).trim();
+	return t.startsWith("N'") && t.endsWith("'") ? t = t.slice(2, -1) : t.startsWith("'") && t.endsWith("'") && (t = t.slice(1, -1)), t;
+}, Vt = (e) => e.onDialectOrElse({
+	mysql: () => Pt(e),
+	mssql: () => Rt(e),
+	sqlite: () => It(e),
+	orElse: () => Mt(e)
+}), Ht = (e, t) => `${t}(${e.precision ?? 38}, ${e.scale ?? 0})`, H = (e) => {
+	switch (e.type) {
+		case "id": return "text";
+		case "text": return "text";
+		case "integer": return "integer";
+		case "real": return "double precision";
+		case "decimal": return Ht(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 "text";
+		case "vector": return "text";
+		case "enum": return "text";
+		case "array": return "text";
+		case "interval": return "interval";
+		case "raw": return e.rawDdl ?? "text";
+	}
+}, U = (e) => {
+	switch (e.type) {
+		case "id": return "VARCHAR(64)";
+		case "text": return e.hasDefault && e.defaultValue !== void 0 || e.oneOf && e.oneOf.length > 0 ? "VARCHAR(255)" : "LONGTEXT";
+		case "integer": return "INT";
+		case "real": return "DOUBLE";
+		case "decimal": return Ht(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 "VARCHAR(64)";
+		case "vector": return "BLOB";
+		case "enum": return "TEXT";
+		case "array": return "JSON";
+		case "interval": return "BIGINT";
+		case "raw": return e.rawDdl ?? "LONGTEXT";
+	}
+}, W = (e) => `"${e}"`, G = (e) => `\`${e.replace(/`/g, "``")}\``, Ut = (e, t) => `ALTER TABLE ${t(e.table)} DROP COLUMN IF EXISTS ${t(e.column)};`, Wt = (e) => `ALTER TABLE ${G(e.table)} DROP COLUMN IF EXISTS ${G(e.column)}, ALGORITHM=COPY;`, Gt = (e, t) => `ALTER TABLE ${t(e.table)} RENAME COLUMN ${t(e.from)} TO ${t(e.to)};`, Kt = (e, t, n) => `ALTER TABLE ${n(e.table)} RENAME COLUMN ${n(e.column)} TO ${n(`${e.column}${mn(t)}`)};`, qt = (e, t, n) => e.hasDefault && e.defaultValue !== void 0 ? `ALTER TABLE ${t(e.table)} ALTER COLUMN ${t(e.column)} SET ${n(e.defaultValue) ?? "DEFAULT NULL"};` : `ALTER TABLE ${t(e.table)} ALTER COLUMN ${t(e.column)} DROP DEFAULT;`, K = (e, t, n) => e.find((e) => e.tableName === t)?.fields[n], Jt = (e, t, n) => {
+	let r = n ?? e.nullable, i = fe(e, "mariadb");
+	return [
+		G(t),
+		O(e, "mariadb"),
+		r ? null : "NOT NULL",
+		i
+	].filter(Boolean).join(" ");
+}, Yt = (e) => e == null ? null : 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" && !Array.isArray(e) ? k(e, "mysql") : null, Xt = (e) => e == null ? null : 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" && !Array.isArray(e) ? k(e, "postgres") : null, q = (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"}`;
+}, Zt = (e) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return A(e.name, "postgres");
+	let t = q(e, "postgres");
+	if (t) return `${W(e.name)} ${H(e)} ${t}`;
+	let n = [W(e.name), H(e)];
+	if (e.type === "id" && n.push("PRIMARY KEY"), e.nullable || n.push("NOT NULL"), e.unique && e.type !== "id" && n.push("UNIQUE"), e.hasDefault) {
+		let t = Xt(e.defaultValue);
+		t && n.push(t);
+	}
+	return e.references && (n.push(`REFERENCES ${W(e.references.table)} (${W(e.references.column)})`), e.references.onDelete && n.push(`ON DELETE ${{
+		cascade: "CASCADE",
+		restrict: "RESTRICT",
+		setNull: "SET NULL",
+		noAction: "NO ACTION"
+	}[e.references.onDelete]}`)), n.join(" ");
+}, J = (e, t) => e.primaryKey && e.primaryKey.length > 0 ? `,\n  PRIMARY KEY (${e.primaryKey.map(t).join(", ")})` : "", Qt = (e) => {
+	let t = e.columns.map((e) => `  ${Zt(e)}`).join(",\n"), n = [`CREATE TABLE IF NOT EXISTS ${W(e.table)} (\n${t}${J(e, W)}\n)`];
+	for (let t of e.indexes) t.name !== `${e.table}_pkey` && n.push(`CREATE ${t.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${W(t.name)} ON ${W(e.table)} (${t.columns.map(yn).join(", ")})`);
+	return n;
+}, $t = 191, en = (e) => {
+	let t = U(e).toUpperCase();
+	return t.endsWith("TEXT") || t.endsWith("BLOB");
+}, tn = (e) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return A(e.name, "mariadb");
+	let t = q(e, "mariadb");
+	if (t) return `${G(e.name)} ${U(e)} ${t}`;
+	let n = [G(e.name), U(e)];
+	if (e.type === "id" && n.push("PRIMARY KEY"), e.nullable || n.push("NOT NULL"), e.unique && e.type !== "id" && !en(e) && n.push("UNIQUE"), e.hasDefault) {
+		let t = Yt(e.defaultValue);
+		t && n.push(t);
+	}
+	return e.references && (n.push(`REFERENCES ${G(e.references.table)} (${G(e.references.column)})`), e.references.onDelete && n.push(`ON DELETE ${{
+		cascade: "CASCADE",
+		restrict: "RESTRICT",
+		setNull: "SET NULL",
+		noAction: "NO ACTION"
+	}[e.references.onDelete]}`)), n.join(" ");
+}, nn = (e) => {
+	let t = new Map(e.columns.map((e) => [e.name, e])), n = (e) => {
+		let n = t.get(e);
+		return n && en(n) ? `${G(e)}(${$t})` : G(e);
+	}, r = e.columns.map((e) => `  ${tn(e)}`).join(",\n"), i = [`CREATE TABLE IF NOT EXISTS ${G(e.table)} (\n${r}${J(e, n)}\n)`];
+	for (let t of e.columns) t.unique && t.type !== "id" && en(t) && i.push(`CREATE UNIQUE INDEX IF NOT EXISTS ${G(`${e.table}_${t.name}_key`)} ON ${G(e.table)} (${n(t.name)})`);
+	for (let t of e.indexes) t.name !== `${e.table}_pkey` && i.push(`CREATE ${t.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${G(t.name)} ON ${G(e.table)} (${t.columns.map(n).join(", ")})`);
+	return i;
+}, rn = {
+	cascade: "CASCADE",
+	restrict: "RESTRICT",
+	setNull: "SET NULL",
+	noAction: "NO ACTION"
+}, an = {
+	cascade: "CASCADE",
+	restrict: "NO ACTION",
+	setNull: "SET NULL",
+	noAction: "NO ACTION"
+}, on = (e) => {
+	switch (e.type) {
+		case "integer":
+		case "boolean": return "INTEGER";
+		case "bigint": return "INTEGER";
+		case "real": return "REAL";
+		case "decimal": return "NUMERIC";
+		case "bytes": return "BLOB";
+		default: return "TEXT";
+	}
+}, Y = (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" && !Array.isArray(e) ? k(e, "sqlite") : null, sn = (e) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return A(e.name, "sqlite");
+	let t = q(e, "sqlite");
+	if (t) return `${W(e.name)} ${on(e)} ${t}`;
+	let n = [W(e.name), on(e)];
+	if (e.type === "id" && n.push("PRIMARY KEY"), e.nullable || n.push("NOT NULL"), e.unique && e.type !== "id" && n.push("UNIQUE"), e.hasDefault) {
+		let t = Y(e.defaultValue, "CURRENT_TIMESTAMP");
+		t && n.push(t);
+	}
+	if (e.references && (n.push(`REFERENCES ${W(e.references.table)} (${W(e.references.column)})`), e.references.onDelete && n.push(`ON DELETE ${rn[e.references.onDelete]}`)), e.oneOf && e.oneOf.length > 0) {
+		let t = e.oneOf.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		n.push(`CHECK (${W(e.name)} IN (${t}))`);
+	}
+	return n.join(" ");
+}, cn = (e) => {
+	let t = e.columns.map((e) => `  ${sn(e)}`).join(",\n"), n = [`CREATE TABLE IF NOT EXISTS ${W(e.table)} (\n${t}${J(e, W)}\n)`];
+	for (let t of e.indexes) t.name !== `${e.table}_pkey` && n.push(`CREATE ${t.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${W(t.name)} ON ${W(e.table)} (${t.columns.map(W).join(", ")})`);
+	return n;
+}, X = (e, t) => {
+	let n = t.find((t) => t.tableName === e);
+	if (!n) return [];
+	let r = F([n]).tables[0], i = `${e}__voltro_rebuild`, a = r.columns.map((e) => W(e.name)).join(", "), o = [
+		...cn({
+			kind: "create-table",
+			table: i,
+			columns: r.columns,
+			indexes: [],
+			...r.primaryKey ? { primaryKey: r.primaryKey } : {}
+		}),
+		`INSERT INTO ${W(i)} (${a}) SELECT ${a} FROM ${W(e)}`,
+		`DROP TABLE ${W(e)}`,
+		`ALTER TABLE ${W(i)} RENAME TO ${W(e)}`
+	];
+	for (let t of r.indexes) t.name !== `${e}_pkey` && o.push(`CREATE ${t.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${W(t.name)} ON ${W(e)} (${t.columns.map(W).join(", ")})`);
+	return o;
+}, ln = (e, t, n, r) => {
+	let i = r ?? e.nullable;
+	return `ALTER TABLE ${Z(n)} ALTER COLUMN ${Z(t)} ${O(e, "mssql")} ${i ? "NULL" : "NOT NULL"};`;
+}, un = (e) => {
+	let t = `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 ${Z(e.table)} DROP CONSTRAINT [' + @dc + ']');`;
+	if (!e.hasDefault) return t;
+	let n = Y(e.defaultValue, "SYSUTCDATETIME()");
+	if (!n) return t;
+	let r = n.replace(/^DEFAULT\s+/i, "");
+	return `${t} ALTER TABLE ${Z(e.table)} ADD DEFAULT ${r} FOR ${Z(e.column)};`;
+}, Z = (e) => `[${e.replace(/]/g, "]]")}]`, dn = (e) => {
+	switch (e.type) {
+		case "id":
+		case "reference": return "NVARCHAR(64)";
+		case "integer": return "INT";
+		case "real": return "FLOAT";
+		case "decimal": return Ht(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)";
+	}
+}, fn = (e, t) => {
+	if (e.type === "id" && e.idScheme?.kind === "numeric") return A(e.name, "mssql");
+	let n = e.type === "text" && t?.has(e.name) ? "NVARCHAR(450)" : dn(e), r = q(e, "mssql");
+	if (r) return `${Z(e.name)} ${r}`;
+	let i = [Z(e.name), n];
+	if (e.type === "id" && i.push("PRIMARY KEY"), e.nullable || i.push("NOT NULL"), e.unique && e.type !== "id" && i.push("UNIQUE"), e.hasDefault) {
+		let t = Y(e.defaultValue, "SYSUTCDATETIME()");
+		t && i.push(t);
+	}
+	return e.references && (i.push(`REFERENCES ${Z(e.references.table)} (${Z(e.references.column)})`), e.references.onDelete && i.push(`ON DELETE ${an[e.references.onDelete]}`)), i.join(" ");
+}, pn = (e) => {
+	let t = (e) => e.replace(/'/g, "''"), n = new Set(e.indexes.flatMap((e) => e.columns)), r = e.columns.map((e) => `  ${fn(e, n)}`).join(",\n"), i = `CREATE TABLE ${Z(e.table)} (\n${r}${J(e, Z)}\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 ${Z(n.name)} ON ${Z(e.table)} (${n.columns.map(Z).join(", ")})`;
+		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;
+}, mn = (e) => `__dropped_${e.replace(/[-:T.Z]/g, "").slice(0, 14)}`, hn = (e, t) => `DROP TABLE IF EXISTS ${t(e.table)};`, gn = (e, t, n) => {
+	let r = `${e.table}${mn(t)}`;
+	return `ALTER TABLE ${n(e.table)} RENAME TO ${n(r)};`;
+}, _n = (e, t, n) => {
+	let r = K(e, t, n);
+	return r ? en({ type: r.type }) : !1;
+}, vn = (e, t, n) => _n(e, t, n) ? `${G(n)}(${$t})` : G(n), yn = (e) => e.startsWith("(") ? e : W(e), bn = (e, t) => `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX ${t ? "CONCURRENTLY " : ""}IF NOT EXISTS ${W(e.index.name)} ON ${W(e.table)} (${e.index.columns.map(yn).join(", ")});`, xn = (e, t) => `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${G(e.index.name)} ON ${G(e.table)} (${e.index.columns.map((n) => vn(t, e.table, n)).join(", ")});`, Sn = (e) => `DROP INDEX IF EXISTS ${W(e.index)};`, Cn = (e) => `DROP INDEX ${G(e.index)} ON ${G(e.table)};`, wn = (e) => `DROP INDEX IF EXISTS ${Z(e.index)} ON ${Z(e.table)};`, Tn = (e) => {
+	let t = (e) => e.replace(/'/g, "''"), n = `CREATE ${e.index.unique ? "UNIQUE " : ""}INDEX ${Z(e.index.name)} ON ${Z(e.table)} (${e.index.columns.map(Z).join(", ")})`;
+	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)}');`;
+}, En = (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];
+		t && t.type === "text" && !t.generatedAs && i.push(`ALTER TABLE ${Z(e)} ALTER COLUMN ${Z(n)} NVARCHAR(450) ${t.nullable ? "NULL" : "NOT NULL"};`);
+	}
+	return i;
+}, Dn = (e) => `ALTER TABLE ${W(e.table)} ADD CONSTRAINT ${W(`${e.table}_${e.column}_key`)} UNIQUE (${W(e.column)});`, On = (e, t) => `ALTER TABLE ${G(e.table)} ADD CONSTRAINT ${G(`${e.table}_${e.column}_key`)} UNIQUE (${vn(t, e.table, e.column)});`, kn = (e) => {
+	let t = e.fields.map((e) => W(e)).join(", ");
+	return `ALTER TABLE ${W(e.table)} ADD CONSTRAINT ${W(e.name)} UNIQUE (${t});`;
+}, An = (e, t) => {
+	let n = e.fields.map((n) => vn(t, e.table, n)).join(", ");
+	return `ALTER TABLE ${G(e.table)} ADD CONSTRAINT ${G(e.name)} UNIQUE (${n});`;
+}, jn = (e) => `ALTER TABLE ${W(e.table)} DROP CONSTRAINT IF EXISTS ${W(e.name)};`, Mn = (e) => `ALTER TABLE ${G(e.table)} DROP INDEX ${G(e.name)};`, Nn = (e) => `ALTER TABLE ${W(e.table)} DROP CONSTRAINT IF EXISTS ${W(`${e.table}_${e.column}_key`)};`, Pn = (e) => `ALTER TABLE ${G(e.table)} DROP INDEX ${G(`${e.table}_${e.column}_key`)};`, Fn = (e, t) => {
+	let n = [], r = t(e.table), i = t(e.column), a = t(e.targetTable), o = t(e.targetColumn);
+	if (e.orphanPolicy) {
+		let t = `${i} IS NOT NULL AND ${i} NOT IN (SELECT ${o} FROM ${a})`;
+		n.push(e.orphanPolicy === "delete" ? `DELETE FROM ${r} WHERE ${t};` : `UPDATE ${r} SET ${i} = NULL WHERE ${t};`);
+	}
+	let s = [
+		`ALTER TABLE ${r}`,
+		`ADD CONSTRAINT ${t(`${e.table}_${e.column}_fkey`)}`,
+		`FOREIGN KEY (${i})`,
+		`REFERENCES ${a} (${o})`
+	];
+	return e.onDelete && s.push(`ON DELETE ${{
+		cascade: "CASCADE",
+		restrict: "RESTRICT",
+		setNull: "SET NULL",
+		noAction: "NO ACTION"
+	}[e.onDelete]}`), n.push(s.join(" ") + ";"), n;
+}, In = (e) => `ALTER TABLE ${W(e.table)} DROP CONSTRAINT IF EXISTS ${W(`${e.table}_${e.column}_fkey`)};`, Ln = (e) => `ALTER TABLE ${G(e.table)} DROP FOREIGN KEY ${G(`${e.table}_${e.column}_fkey`)};`, Rn = (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}));`;
+}, zn = (e) => `ALTER TABLE ${W(e.table)} DROP CONSTRAINT IF EXISTS ${W(`${e.table}_${e.column}_check`)};`, Bn = (e) => `ALTER TABLE ${G(e.table)} DROP CHECK ${G(`${e.table}_${e.column}_check`)};`, Vn = (e, t, n, r) => {
+	let i = e.column, a = r === "mariadb", o = a ? G : r === "mssql" ? Z : W, s = a ? U(i) : r === "mssql" ? dn(i) : r === "sqlite" ? on(i) : H(i), c = r === "mssql" ? "ADD" : "ADD COLUMN", l = (e) => a ? Yt(e) : r === "mssql" ? Y(e, "SYSUTCDATETIME()") : r === "sqlite" ? Y(e, "CURRENT_TIMESTAMP") : Xt(e), u = q(i, r);
+	if (u) {
+		let t = r === "mssql" ? `${o(i.name)} ${u}` : `${o(i.name)} ${s} ${u}`;
+		return {
+			pre: [`ALTER TABLE ${o(e.table)} ${c} ${t};`],
+			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(" ")};`],
+			post: []
+		};
+	}
+	if (t.classification === "needs-default") {
+		let t = l(i.defaultValue) ?? "DEFAULT NULL";
+		return {
+			pre: [`ALTER TABLE ${o(e.table)} ${c} ${o(i.name)} ${s} NOT NULL ${t};`],
+			post: []
+		};
+	}
+	let d = n(e.table, i.name), f = 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;`, p = {
+		pre: [`ALTER TABLE ${o(e.table)} ${c} ${o(i.name)} ${s};`],
+		post: f ? [f] : []
+	};
+	return d?.sql && (p.backfillKind = "sql", p.backfillSql = d.sql), d?.js && (p.backfillKind = "js", p.backfillJs = d.js), d?.batchSize !== void 0 && (p.batchSize = d.batchSize), d?.sleepMs !== void 0 && (p.sleepMs = d.sleepMs), p;
+}, Hn = (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
+		};
+	};
+}, Q = (e, t, n) => e.unsafe(t).pipe(d.tapError((e) => d.sync(() => {
+	process.stderr.write(_(`applier: statement failed (op=${n})`, t, e, 400));
+})), d.map(() => void 0)), $ = (e, t, n) => d.forEach(t, (t) => Q(e, t, n), { discard: !0 }), Un = (e, t, n) => d.gen(function* () {
+	let r = process.hrtime.bigint(), i = Hn(n.declared), a = t.op;
+	switch (a.kind) {
+		case "create-table": {
+			let t = yield* e.onDialectOrElse({
+				mysql: () => d.succeed(nn(a)),
+				mssql: () => d.succeed(pn(a)),
+				sqlite: () => d.succeed(cn(a)),
+				orElse: () => d.succeed(Qt(a))
+			});
+			for (let n of t) yield* Q(e, n, a.kind);
+			break;
+		}
+		case "drop-table": {
+			let t = process.env.VOLTRO_SOFT_DROP === "1", n = (/* @__PURE__ */ new Date()).toISOString(), r = (e) => t ? gn(a, n, e) : hn(a, e);
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, r(G), a.kind),
+				orElse: () => Q(e, r(W), a.kind)
+			});
+			break;
+		}
+		case "drop-column": {
+			let t = process.env.VOLTRO_SOFT_DROP === "1", n = (/* @__PURE__ */ new Date()).toISOString();
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, t ? Kt(a, n, G) : Wt(a), a.kind),
+				orElse: () => Q(e, t ? Kt(a, n, W) : Ut(a, W), a.kind)
+			});
+			break;
+		}
+		case "rename-column":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Gt(a, G), a.kind),
+				mssql: () => Q(e, `EXEC sp_rename N'${a.table.replace(/'/g, "''")}.${a.from.replace(/'/g, "''")}', N'${a.to.replace(/'/g, "''")}', 'COLUMN';`, a.kind),
+				orElse: () => Q(e, Gt(a, W), a.kind)
+			});
+			break;
+		case "add-index":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, xn(a, n.declared), a.kind),
+				mssql: () => $(e, [...En(a.table, a.index.columns, n.declared), Tn(a)], a.kind),
+				orElse: () => Q(e, bn(a, t.classification === "online-required"), a.kind)
+			});
+			break;
+		case "drop-index":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Cn(a), a.kind),
+				mssql: () => Q(e, wn(a), a.kind),
+				orElse: () => Q(e, Sn(a), a.kind)
+			});
+			break;
+		case "add-unique":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, On(a, n.declared), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				mssql: () => $(e, [...En(a.table, [a.column], n.declared), Dn(a)], a.kind),
+				orElse: () => Q(e, Dn(a), a.kind)
+			});
+			break;
+		case "drop-unique":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Pn(a), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, Nn(a), a.kind)
+			});
+			break;
+		case "add-unique-composite":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, An(a, n.declared), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				mssql: () => $(e, [...En(a.table, a.fields, n.declared), kn(a)], a.kind),
+				orElse: () => Q(e, kn(a), a.kind)
+			});
+			break;
+		case "drop-unique-composite":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Mn(a), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, jn(a), a.kind)
+			});
+			break;
+		case "add-foreign-key":
+			yield* e.onDialectOrElse({
+				mysql: () => $(e, Fn(a, G), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => $(e, Fn(a, W), a.kind)
+			});
+			break;
+		case "add-column": {
+			let n = Vn(a, t, i, yield* e.onDialectOrElse({
+				mysql: () => d.succeed("mariadb"),
+				mssql: () => d.succeed("mssql"),
+				sqlite: () => d.succeed("sqlite"),
+				orElse: () => d.succeed("postgres")
+			}));
+			for (let t of n.pre) yield* Q(e, t, a.kind);
+			if (n.backfillKind === "sql" && n.backfillSql) if (!(t.classification === "online-required" || n.batchSize !== void 0)) yield* e`UPDATE ${e(a.table)} SET ${e(a.column.name)} = ${n.backfillSql}`;
+			else {
+				let t = n.batchSize ?? 5e3, r = n.sleepMs ?? 0, i, o = 0;
+				for (;;) {
+					let s = i === void 0 ? yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(a.column.name)} IS NULL ORDER BY ${e("id")} LIMIT ${t}` : yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(a.column.name)} IS NULL AND ${e("id")} > ${i} ORDER BY ${e("id")} LIMIT ${t}`;
+					if (s.length === 0) break;
+					let c = s.map((e) => e.id);
+					yield* e`UPDATE ${e(a.table)} SET ${e(a.column.name)} = ${n.backfillSql} WHERE ${e("id")} IN ${e.in(c)}`, o += s.length, yield* d.logInfo(`backfill ${a.table}.${a.column.name}: ${o} rows`).pipe(d.annotateLogs({
+						scope: "voltro:migrate",
+						mode: "sql-batched"
+					})), i = s[s.length - 1].id, r > 0 && (yield* d.sleep(`${r} millis`));
+				}
+			}
+			else if (n.backfillKind === "js" && n.backfillJs) {
+				let t = n.batchSize ?? 1e3, r = n.sleepMs ?? 0, i, o = 0;
+				for (;;) {
+					let s = i === void 0 ? yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(a.column.name)} IS NULL ORDER BY ${e("id")} LIMIT ${t}` : yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(a.column.name)} IS NULL AND ${e("id")} > ${i} ORDER BY ${e("id")} LIMIT ${t}`;
+					if (s.length === 0) break;
+					for (let t of s) {
+						let r = yield* d.tryPromise({
+							try: () => Promise.resolve(n.backfillJs({ id: t.id })),
+							catch: (e) => e
+						}).pipe(d.orDie);
+						yield* e`UPDATE ${e(a.table)} SET ${e(a.column.name)} = ${r} WHERE ${e("id")} = ${t.id}`;
+					}
+					o += s.length, yield* d.logInfo(`backfill ${a.table}.${a.column.name}: ${o} rows processed`).pipe(d.annotateLogs({
+						scope: "voltro:migrate",
+						table: a.table,
+						column: a.column.name
+					})), i = s[s.length - 1].id, r > 0 && (yield* d.sleep(`${r} millis`));
+				}
+			}
+			for (let t of n.post) yield* Q(e, t, a.kind);
+			break;
+		}
+		case "alter-column-nullability":
+			yield* e.onDialectOrElse({
+				mysql: () => {
+					let t = K(n.declared, a.table, a.column);
+					return t ? Q(e, `ALTER TABLE ${G(a.table)} MODIFY COLUMN ${Jt(t, a.column, a.toNullable)};`, a.kind) : d.die(/* @__PURE__ */ Error(`alter-column-nullability on mariadb needs the declared column '${a.table}.${a.column}' (to render MODIFY COLUMN); it was not in ctx.declared.`));
+				},
+				mssql: () => {
+					let t = K(n.declared, a.table, a.column);
+					return t ? Q(e, ln(t, a.column, a.table, a.toNullable), a.kind) : d.die(/* @__PURE__ */ Error(`alter-column-nullability on mssql needs the declared column '${a.table}.${a.column}'.`));
+				},
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, `ALTER TABLE ${W(a.table)} ALTER COLUMN ${W(a.column)} ${a.toNullable ? "DROP NOT NULL" : "SET NOT NULL"};`, a.kind)
+			});
+			break;
+		case "alter-column-default":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, qt(a, G, Yt), a.kind),
+				mssql: () => Q(e, un(a), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, qt(a, W, Xt), a.kind)
+			});
+			break;
+		case "alter-column-type": {
+			let r = H({ type: a.to }), i = a.using ? ` USING ${a.using}` : "";
+			if (t.classification !== "online-required") {
+				yield* e.onDialectOrElse({
+					mysql: () => {
+						let t = K(n.declared, a.table, a.column);
+						return t ? Q(e, `ALTER TABLE ${G(a.table)} MODIFY COLUMN ${Jt(t, a.column)};`, a.kind) : d.die(/* @__PURE__ */ Error(`alter-column-type on mariadb needs the declared column '${a.table}.${a.column}' (to render MODIFY COLUMN); it was not in ctx.declared.`));
+					},
+					mssql: () => {
+						let t = K(n.declared, a.table, a.column);
+						return t ? Q(e, ln(t, a.column, a.table), a.kind) : d.die(/* @__PURE__ */ Error(`alter-column-type on mssql needs the declared column '${a.table}.${a.column}'.`));
+					},
+					sqlite: () => $(e, X(a.table, n.declared), a.kind),
+					orElse: () => Q(e, `ALTER TABLE ${W(a.table)} ALTER COLUMN ${W(a.column)} TYPE ${r}${i};`, a.kind)
+				});
+				break;
+			}
+			yield* e.onDialectOrElse({
+				mysql: () => d.die(/* @__PURE__ */ Error(`online-required alter-column-type on ${a.table}.${a.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: () => d.void
+			});
+			let o = `${a.column}__shadow`, s = `${a.column}__old`;
+			yield* e.unsafe(`ALTER TABLE ${W(a.table)} ADD COLUMN ${W(o)} ${r}`);
+			let c = a.using ?? W(a.column), l;
+			for (;;) {
+				let t = l === void 0 ? yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(o)} IS NULL ORDER BY ${e("id")} LIMIT 5000` : yield* e`SELECT ${e("id")} FROM ${e(a.table)} WHERE ${e(o)} IS NULL AND ${e("id")} > ${l} ORDER BY ${e("id")} LIMIT 5000`;
+				if (t.length === 0) break;
+				yield* e.unsafe(`UPDATE ${W(a.table)} SET ${W(o)} = ${c} WHERE ${W(a.column)} IS NOT NULL AND ${W(o)} IS NULL AND ${W("id")} IN (${t.map((e) => `'${e.id.replace(/'/g, "''")}'`).join(",")})`), l = t[t.length - 1].id;
+			}
+			yield* d.logInfo(`alter-column-type shadow ${a.table}.${a.column}: shadow populated`).pipe(d.annotateLogs({ scope: "voltro:migrate" })), yield* e.unsafe(`ALTER TABLE ${W(a.table)} RENAME COLUMN ${W(a.column)} TO ${W(s)}`), yield* e.unsafe(`ALTER TABLE ${W(a.table)} RENAME COLUMN ${W(o)} TO ${W(a.column)}`), yield* e.unsafe(`ALTER TABLE ${W(a.table)} DROP COLUMN ${W(s)}`);
+			break;
+		}
+		case "drop-foreign-key":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Ln(a), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, In(a), a.kind)
+			});
+			break;
+		case "add-check":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Rn(a, G), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, Rn(a, W), a.kind)
+			});
+			break;
+		case "drop-check":
+			yield* e.onDialectOrElse({
+				mysql: () => Q(e, Bn(a), a.kind),
+				sqlite: () => $(e, X(a.table, n.declared), a.kind),
+				orElse: () => Q(e, zn(a), a.kind)
+			});
+			break;
+	}
+	return {
+		op: a,
+		status: "applied",
+		durationMs: Number((process.hrtime.bigint() - r) / 1000000n)
+	};
+}), Wn = (e, t, n) => d.gen(function* () {
+	let r = t.operations.filter((e) => e.blocked);
+	if (r.length > 0) return yield* d.die(/* @__PURE__ */ Error(`applyPlan: refusing to execute — ${r.length} blocked operations. Run \`voltro db plan\` to see the fixes.`));
+	yield* w(e);
+	let i = Date.now(), a = [];
+	try {
+		let r = yield* e.onDialectOrElse({
+			pg: () => d.succeed(!0),
+			mssql: () => d.succeed(!0),
+			orElse: () => d.succeed(!1)
+		}), i = r ? t.operations.filter((e) => e.classification !== "online-required") : [], o = r ? t.operations.filter((e) => e.classification === "online-required") : t.operations;
+		i.length > 0 && (yield* e.withTransaction(d.gen(function* () {
+			let e = yield* p.SqlClient;
+			for (let t of i) a.push(yield* Un(e, t, n));
+		})));
+		for (let t of o) a.push(yield* Un(e, t, n));
+	} finally {
+		yield* T(e).pipe(d.orDie);
+	}
+	let o = Date.now() - i, s = `plan_${Date.now().toString(36)}`, c = (/* @__PURE__ */ new Date()).toISOString(), l = yield* e.onDialectOrElse({
+		mysql: () => d.succeed(c.replace("T", " ").replace("Z", "")),
+		orElse: () => d.succeed(c)
+	});
+	return yield* e`
+      INSERT INTO ${e("_voltro_migration_plans")}
+        (${e("id")}, ${e("fingerprint")}, ${e("operations")},
+         ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+         ${e("durationMs")}, ${e("appliedAt")}, ${e("notes")})
+      VALUES
+        (${s}, ${t.toFingerprint}, ${JSON.stringify(t.operations)},
+         ${n.appliedBy}, ${n.environment}, ${n.source},
+         ${o}, ${l}, ${n.notes ?? null})
+    `, {
+		id: s,
+		appliedAt: c,
+		fingerprint: t.toFingerprint,
+		operations: t.operations,
+		appliedBy: n.appliedBy,
+		environment: n.environment,
+		durationMs: o,
+		source: n.source,
+		...n.notes ? { notes: n.notes } : {}
+	};
+}), Gn = (e) => e.operations.filter((e) => e.blocked).map((e) => `  - ${e.op.kind} ${"table" in e.op ? `[${e.op.table}]` : ""}: ${e.reason ?? "<no reason>"}\n    fix: ${e.blocked?.fix ?? "<no fix>"}`).join("\n"), Kn = (e) => e`
+    SELECT fingerprint
+    FROM _voltro_migration_plans
+    ORDER BY ${e("appliedAt")} DESC
+    LIMIT 1
+  `.pipe(d.map((e) => e.length > 0 ? e[0].fingerprint : void 0), d.catchAll(() => d.succeed(void 0))), qn = (e, t) => d.gen(function* () {
+	let n = N(F(t)), r = yield* Kn(e);
+	return r === n ? {
+		kind: "up-to-date",
+		fingerprint: n
+	} : {
+		kind: "prod-mismatch",
+		expected: n,
+		...r === void 0 ? {} : { actual: r }
+	};
+}), Jn = [
+	"pgeagertest_",
+	"mig_e2e_",
+	"mig_test_",
+	"mysqleagertest_",
+	"mssqleagertest_",
+	"sqliteeagertest_"
+], Yn = (e) => Jn.some((t) => e.startsWith(t)), Xn = (e, t) => d.gen(function* () {
+	if (process.env.VOLTRO_TEST_FIXTURE_GC === "off") return [];
+	let n = t.filter((e) => Yn(e.name)).map((e) => e.name);
+	if (n.length === 0) return [];
+	for (let t of n) yield* e.unsafe(`DROP TABLE IF EXISTS "${t}" CASCADE`).pipe(d.catchAll(() => d.void));
+	return n;
+}), Zn = () => {
+	let e = (process.env.VOLTRO_DB_IGNORE_TABLES ?? "").split(",").map((e) => e.trim()).filter((e) => e.length > 0);
+	return e.length > 0 ? { ignoreTables: e } : {};
+}, Qn = (e, t, n) => d.gen(function* () {
+	let r = t.filter((e) => !$e(e.tableName));
+	if (process.env.VOLTRO_MIGRATE_FORCE !== "1") {
+		let t = N(F(r));
+		if ((yield* Kn(e)) === t) return {
+			kind: "up-to-date",
+			fingerprint: t
+		};
+	}
+	let i = yield* Vt(e), a = yield* Xn(e, i.tables);
+	a.length > 0 && (yield* d.logInfo(`auto-migrate: reaped ${a.length} test-fixture leftover(s)`).pipe(d.annotateLogs({
+		scope: "voltro:migrate",
+		count: a.length
+	})), i = yield* Vt(e));
+	let o = wt({
+		declared: r,
+		live: { tables: i.tables.filter((e) => !$e(e.name)) },
+		...Zn()
+	});
+	if (o.summary.blocked > 0) {
+		let e = o.operations.filter((e) => e.blocked).every((e) => e.classification === "lossy");
+		if (process.env.VOLTRO_DESTRUCTIVE_OK !== "1" || !e) return {
+			kind: "refused-blocked",
+			plan: o
+		};
+	}
+	return o.operations.length === 0 ? {
+		kind: "up-to-date",
+		fingerprint: o.toFingerprint
+	} : {
+		kind: "applied",
+		applied: yield* Wn(e, o, {
+			declared: t,
+			appliedBy: n.appliedBy,
+			environment: n.environment === "prod" ? "dev" : n.environment,
+			source: "auto-diff"
+		}),
+		plan: o
+	};
+}), $n = (e, t, n) => process.env.VOLTRO_AUTO_MIGRATE === "0" ? d.succeed({
+	kind: "skipped",
+	reason: "VOLTRO_AUTO_MIGRATE=0"
+}) : n.environment === "prod" ? qn(e, t) : Qn(e, t, n), er = (e, t) => {
+	switch (e.kind) {
+		case "skipped": return `auto-migrate: skipped (${e.reason})`;
+		case "up-to-date": return `auto-migrate: schema up to date (${t}, fingerprint=${P(e.fingerprint)})`;
+		case "applied": {
+			let t = e.plan.summary;
+			return `auto-migrate: applied ${e.plan.operations.length} op(s) in ${e.applied.durationMs}ms [safe=${t.safe} needs-default=${t.needsDefault} needs-backfill=${t.needsBackfill} rename=${t.needsRenameAnnotation} lossy=${t.lossy}] fingerprint=${P(e.applied.fingerprint)}`;
+		}
+		case "prod-mismatch": return `auto-migrate: SCHEMA FINGERPRINT MISMATCH — declared=${P(e.expected)}` + (e.actual ? ` live=${P(e.actual)}` : " live=<no _voltro_migration_plans row>") + ". Run `voltro db apply --plan plan.json` from the deploy pipeline before serving.";
+		case "refused-blocked": {
+			let t = e.plan.operations.filter((e) => e.blocked), n = t.filter((e) => e.op.kind === "drop-table").length, r = t.filter((e) => e.op.kind === "add-column").length, i = t.filter((e) => e.op.kind === "drop-column").length, a = t.filter((e) => e.classification === "needs-rename-annotation").length, o = `auto-migrate: REFUSED — ${e.plan.summary.blocked} blocked operation(s):\n` + Gn(e.plan), s = [""];
+			return n > 0 && s.push(`${n} table(s) exist in the live DB but aren't in your declared schema.`, "This is usually one of three things:", "  (a) You're iterating on the schema — the table file got renamed, moved, or temporarily commented out.", "      → Restore the declaration. Your data stays intact.", "  (b) You want to KEEP the table but NOT manage it with Voltro (a leftover from another tool —", "      a Strapi/Rails/legacy migration artifact, or an externally-owned table).", `      → Set \`VOLTRO_DB_IGNORE_TABLES=${t.filter((e) => e.op.kind === "drop-table").map((e) => "table" in e.op ? e.op.table : "").filter(Boolean).join(",")}\` (comma-separated).`, "        The planner excludes those tables from the diff entirely — it never drops them, and they", "        stop blocking your OTHER (additive) changes. This is the fix when a leftover freezes your schema.", "  (c) You actually want to drop the table.", "      → Add it to your declared set + chain `.dropped()` on it, OR", "        write a file-based migration in `migrations/` that DROPs it, OR", "        set `VOLTRO_DESTRUCTIVE_OK=1` for ONE `voltro dev` run (acknowledges data loss).", "  Soft-drop: set `VOLTRO_SOFT_DROP=1` alongside DESTRUCTIVE_OK to RENAME instead of DROP", "  (data survives as `<name>__dropped_<ts>` for ~7d; restorable via `voltro db restore-snapshot`)."), r > 0 && s.push(`${r} required column(s) need a backfill strategy before adding to a populated table.`, "  → Annotate the column: `.backfill(sql`<expr>`)` or `.backfill(row => <fn>)` or `.default(<value>)`.", "  Existing rows get the backfill value; the column then lands as NOT NULL."), i > 0 && s.push(`${i} column(s) are missing from your declared schema.`, "  → If intentional: chain `.dropped()` on the column slot in the table declaration.", "  → If a typo: restore the field. Data survives until you drop it."), a > 0 && s.push(`${a} column(s) look like renames (one column gone + a new one of same shape appeared).`, "  → On the NEW column add `.renamedFrom('<oldName>')` so the planner emits RENAME instead of DROP+ADD."), s.push("", "See `voltro db plan` for the full machine-readable diff."), o + "\n" + s.join("\n");
+		}
+	}
+}, tr = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git",
+	".framework"
+]), nr = async (e) => {
+	let t = [], n = async (e) => {
+		let r = await h.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let i of r) {
+			if (tr.has(i.name)) continue;
+			let r = g(e, i.name);
+			i.isDirectory() ? await n(r) : i.isFile() && u.test(i.name) && t.push(r);
+		}
+	};
+	return await n(e), t.sort((e, t) => {
+		let n = e.split("/").pop() ?? e, r = t.split("/").pop() ?? t;
+		return n.localeCompare(r);
+	});
+}, rr = async (e) => {
+	let t = [];
+	for (let n of e) {
+		let e = (await import(ee(n).href)).default;
+		if (!s(e)) {
+			process.stderr.write(`[voltro:migrate] ${n} has no default-exported \`migration(...)\` — skipped\n`);
+			continue;
+		}
+		t.push({
+			file: n,
+			migration: e
+		});
+	}
+	return t;
+}, ir = (e) => e`
+    SELECT ${e("id")}
+    FROM ${e("_voltro_migration_plans")}
+    WHERE ${e("source")} = 'file'
+  `.pipe(d.map((e) => e.map((e) => e.id)), d.catchAll(() => d.succeed([]))), ar = (e, t, n, r) => d.gen(function* () {
+	let i = Date.now(), a = (/* @__PURE__ */ new Date()).toISOString(), o = {
+		sql: e,
+		log: {
+			info: (e, n) => d.logInfo(e).pipe(d.annotateLogs({
+				scope: `migrations:file:${t.migration.id}`,
+				...n ?? {}
+			})),
+			warn: (e, n) => d.logWarning(e).pipe(d.annotateLogs({
+				scope: `migrations:file:${t.migration.id}`,
+				...n ?? {}
+			}))
+		},
+		appliedAt: a
+	}, s = t.migration.up(o);
+	d.isEffect(s) ? yield* s : yield* d.tryPromise({
+		try: () => s,
+		catch: (e) => e
+	});
+	let c = Date.now() - i;
+	return !d.isEffect(s) && c < 2 && (yield* d.logWarning(`migration ${t.migration.id}: up() resolved in ${c}ms — did the body \`await\` an \`@effect/sql\` Effect by accident? \`sql.unsafe(...)\` returns an Effect, not a Promise; \`await\` on it is a silent no-op. Switch the body to \`Effect.gen(function* () { yield* sql.unsafe(...) })\` form.`).pipe(d.annotateLogs({ scope: `migrations:file:${t.migration.id}` }))), yield* e`
+      INSERT INTO ${e("_voltro_migration_plans")}
+        (${e("id")}, ${e("fingerprint")}, ${e("operations")},
+         ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+         ${e("durationMs")}, ${e("appliedAt")}, ${e("notes")})
+      VALUES
+        (${t.migration.id}, ${""}, ${JSON.stringify([{
+		kind: "file",
+		file: t.file
+	}])},
+         ${r}, ${n}, ${"file"},
+         ${c}, ${a}, ${t.migration.description})
+    `, { durationMs: c };
+}), or = (e, t) => d.gen(function* () {
+	let n = yield* d.tryPromise({
+		try: () => nr(g(t.projectRoot, "migrations")),
+		catch: (e) => e
+	});
+	if (n.length === 0) return {
+		applied: [],
+		skipped: []
+	};
+	let r = yield* d.tryPromise({
+		try: () => rr(n),
+		catch: (e) => e
+	});
+	if (r.length === 0) return {
+		applied: [],
+		skipped: []
+	};
+	let i = new Set(yield* ir(e)), a = r.filter((e) => !i.has(e.migration.id)), o = r.filter((e) => i.has(e.migration.id)).map((e) => e.migration.id);
+	if (a.length === 0) return {
+		applied: [],
+		skipped: o
+	};
+	yield* w(e);
+	let s = [];
+	try {
+		for (let n of a) {
+			yield* d.logInfo("file-based migration applying").pipe(d.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				file: n.file
+			}));
+			let { durationMs: r } = yield* ar(e, n, t.env, t.appliedBy);
+			s.push({
+				id: n.migration.id,
+				durationMs: r
+			}), yield* d.logInfo("file-based migration applied").pipe(d.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				durationMs: r
+			}));
+		}
+	} finally {
+		yield* T(e).pipe(d.orDie);
+	}
+	return {
+		applied: s,
+		skipped: o
+	};
+}), sr = (e, t) => e`
+    SELECT ${e("id")}
+    FROM ${e("_voltro_migration_plans")}
+    WHERE ${e("id")} = ${t} AND ${e("source")} = 'file'
+    LIMIT 1
+  `, cr = (e, t) => d.gen(function* () {
+	if (!(yield* sr(e, t.id))[0]) return yield* d.fail(/* @__PURE__ */ Error(`rollback: ${t.id} not found in _voltro_migration_plans (file source)`));
+	let n = yield* d.tryPromise({
+		try: () => nr(g(t.projectRoot, "migrations")),
+		catch: (e) => e
+	}), r = (yield* d.tryPromise({
+		try: () => rr(n),
+		catch: (e) => e
+	})).find((e) => e.migration.id === t.id);
+	if (!r) return yield* d.fail(/* @__PURE__ */ Error(`rollback: file for migration ${t.id} not found on disk under ${t.projectRoot}/migrations/`));
+	yield* w(e);
+	let i = Date.now();
+	try {
+		let n = {
+			sql: e,
+			log: {
+				info: (e, n) => d.logInfo(e).pipe(d.annotateLogs({
+					scope: `migrations:file:${t.id}`,
+					...n ?? {}
+				})),
+				warn: (e, n) => d.logWarning(e).pipe(d.annotateLogs({
+					scope: `migrations:file:${t.id}`,
+					...n ?? {}
+				}))
+			},
+			appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}, a = r.migration.down(n);
+		d.isEffect(a) ? yield* a : yield* d.tryPromise({
+			try: () => a,
+			catch: (e) => e
+		});
+		let o = Date.now() - i;
+		return yield* e`DELETE FROM ${e("_voltro_migration_plans")} WHERE ${e("id")} = ${t.id} AND ${e("source")} = 'file'`, {
+			id: t.id,
+			durationMs: o
+		};
+	} finally {
+		yield* T(e).pipe(d.orDie);
+	}
+}), lr = (e) => d.gen(function* () {
+	let t = yield* p.SqlClient, n = yield* t`
+      SELECT id, fingerprint, appliedAt FROM _voltro_migration_plans
+      WHERE source = 'auto-diff'
+        AND squashedAt IS NULL
+        AND appliedAt <  ${e.before}
+      ORDER BY appliedAt DESC
+    `;
+	if (n.length === 0) return yield* d.fail(/* @__PURE__ */ Error(`squash: no rows applied before ${e.before}`));
+	let r = n[0];
+	if (r.fingerprint !== e.fingerprint) return yield* d.fail(/* @__PURE__ */ Error(`squash: latest pre-squash fingerprint (${r.fingerprint.slice(0, 12)}…) differs from current declared-schema fingerprint (${e.fingerprint.slice(0, 12)}…). This means the working tree carries un-applied changes — squashing now would lock the drift in.\n\nFix: run \`voltro db apply\` first to align the live schema with the working tree, then re-squash.`));
+	yield* t`
+      UPDATE _voltro_migration_plans
+      SET squashedAt = CURRENT_TIMESTAMP
+      WHERE id IN ${t.in(n.map((e) => e.id))}
+    `;
+	let i = `plan_squash_${Math.floor(Date.now() / 1e3).toString(36)}`;
+	return yield* t`
+      INSERT INTO _voltro_migration_plans
+        (id, fingerprint, operations, rollbackPlan, appliedBy, environment, source,
+         onlineStrategy, durationMs, notes, squashedAt, appliedAt, createdAt, updatedAt)
+      VALUES (
+        ${i},
+        ${e.fingerprint},
+        ${JSON.stringify({
+		kind: "squash-snapshot",
+		rowsSquashed: n.length
+	})},
+        ${null},
+        ${e.appliedBy},
+        ${e.environment},
+        ${"squash-snapshot"},
+        ${null},
+        ${0},
+        ${e.note ?? null},
+        ${null},
+        ${"CURRENT_TIMESTAMP"},
+        ${"CURRENT_TIMESTAMP"},
+        ${"CURRENT_TIMESTAMP"}
+      )
+    `, {
+		squashedCount: n.length,
+		snapshotFingerprint: e.fingerprint,
+		snapshotId: i
+	};
+}), ur = (e, ...t) => ({
+	_tag: "RawSqlFragment",
+	strings: [...e],
+	values: [...t]
+}), dr = (e) => typeof e == "object" && !!e && e._tag === "RawSqlFragment";
+//#endregion
+export { u as FILE_MIGRATION_PATTERN, b as VOLTRO_MIGRATION_LOCK_KEY, it as _internalCmp, w as acquireMigrationLock, Be as applyNamespacedSchema, Wn as applyPlan, Pe as applySchema, jt as chunkTables, F as declaredSnapshot, fe as defaultClause, k as defaultJsonClause, er as describeOutcome, Ut as emitDropColumnDdl, Wt as emitDropColumnDdlMysql, Ne as emitFrameworkBootstrapSql, je as emitNamespaceProvisionDdl, Me as emitNamespacedSchemaSql, M as emitSchemaSql, N as fingerprintSchema, Zn as ignoreTablesFromEnv, Vt as introspectSchema, s as isFileMigration, dr as isRawSqlFragment, Et as mapPgType, l as migration, A as numericIdSql, Tt as parseEnumCheck, wt as planMigrations, Ve as provisionTenantNamespace, T as releaseMigrationLock, tn as renderColumnMysql, Zt as renderColumnPg, cr as rollbackFileBasedMigration, or as runFileBasedMigrations, He as runFrameworkBootstrap, ze as runMigrate, $n as runPlannedMigrations, P as shortFingerprint, ur as sql, O as sqlType, lr as squashMigrationPlans, E as withMigrationLock };