@voltro/database 0.85.0 → 0.86.0

package/dist/migrations/boot.js

@@ -0,0 +1,196 @@
+import { agedSoftDropSnapshots as e, describeAgedSoftDropSnapshots as t, plannableLiveTables as n } from "./frameworkLiveTables.js";
+import { dialectOf as r } from "./resumeLedger.js";
+import { ensureFullTextIndexes as i } from "../migrate.js";
+import { fingerprintSchema as a, shortFingerprint as o } from "./fingerprint.js";
+import { declaredSnapshot as s } from "./declaredSchema.js";
+import { detectReactiveTriggerDrift as c, formatReactiveTriggerDrift as l } from "./reactiveTriggerDrift.js";
+import { planMigrations as u } from "./planner.js";
+import { introspectSchema as d } from "./introspect.js";
+import { limitClause as f } from "./sqlLimit.js";
+import { appliedAtValue as p } from "./appliedAtValue.js";
+import { applyPlan as m, hasInterruptedMigration as h } from "./applier.js";
+import { verifySqliteDecimalStorage as g } from "./sqliteDecimalBoot.js";
+import { describesSchema as _ } from "./ledgerRows.js";
+import { convergeUndeclaredCharset as v, describeUndeclaredCharsetWork as y, isUndeclaredCharsetWorkEmpty as b, readUndeclaredCharsetColumns as x, undeclaredCharsetWork as S } from "./undeclaredCharset.js";
+import { Effect as C } from "effect";
+//#region src/migrations/boot.ts
+var w = (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"), T = (e) => e`
+    SELECT fingerprint
+    FROM _voltro_migration_plans
+    WHERE ${_(e)}
+    ORDER BY ${e("appliedAt")} DESC
+    ${f(e, 1)}
+  `.pipe(C.map((e) => e.length > 0 ? e[0].fingerprint : void 0), C.catch((t) => e`SELECT COUNT(*) AS n FROM _voltro_migration_plans`.pipe(C.matchEffect({
+	onFailure: () => C.succeed(void 0),
+	onSuccess: () => C.die(/* @__PURE__ */ Error(`reading the newest applied plan from _voltro_migration_plans failed while the table exists — this is a query defect, not a missing ledger: ${String(t)}`))
+})))), E = (e, t, n) => C.gen(function* () {
+	if ((yield* T(e)) === t.toFingerprint) return "already-current";
+	let r = `plan_${Date.now().toString(36)}`, i = (/* @__PURE__ */ new Date()).toISOString(), a = yield* p(e, i);
+	return yield* e`
+      INSERT INTO ${e("_voltro_migration_plans")}
+        (${e("id")}, ${e("fingerprint")}, ${e("liveFingerprint")}, ${e("operations")},
+         ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+         ${e("durationMs")}, ${e("appliedAt")}, ${e("notes")})
+      VALUES
+        (${r}, ${t.toFingerprint}, ${t.fromFingerprint}, ${JSON.stringify([])},
+         ${n.appliedBy}, ${n.environment}, ${n.source},
+         ${0}, ${a}, ${"no DDL — the declared schema already matched the database"})
+    `, "recorded";
+}).pipe(C.catch(() => C.succeed("already-current"))), D = (e, t, n) => C.gen(function* () {
+	let i = r(e), o = a(s(t, i, { charset: n.charset })), c = yield* T(e);
+	return c === o ? {
+		kind: "up-to-date",
+		fingerprint: o
+	} : {
+		kind: "prod-mismatch",
+		expected: o,
+		...c === void 0 ? {} : { actual: c }
+	};
+}), O = [
+	"pgeagertest_",
+	"mig_e2e_",
+	"mig_test_",
+	"mysqleagertest_",
+	"mssqleagertest_",
+	"sqliteeagertest_"
+], k = (e) => O.some((t) => e.startsWith(t)), A = (e, t) => C.gen(function* () {
+	if (process.env.VOLTRO_TEST_FIXTURE_GC === "off") return [];
+	let n = t.filter((e) => k(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(C.catch(() => C.void));
+	return n;
+}), j = () => {
+	let e = (process.env.VOLTRO_DB_IGNORE_TABLES ?? "").split(",").map((e) => e.trim()).filter((e) => e.length > 0);
+	return e.length > 0 ? { ignoreTables: e } : {};
+}, M = (e) => {
+	if (e === void 0) return;
+	let t = e.trim();
+	if (t === "") return;
+	if (t === "1" || t.toLowerCase() === "true") return { kind: "all" };
+	let n = t.split(",").map((e) => e.trim()).filter((e) => e.length > 0);
+	return n.length > 0 ? {
+		kind: "tables",
+		tables: new Set(n)
+	} : void 0;
+}, N = (e) => typeof e.table == "string" ? e.table : void 0, P = (e, t = { kind: "all" }) => ({
+	...e,
+	operations: e.operations.map((e) => {
+		if (!e.blocked || e.classification !== "lossy") return e;
+		if (t?.kind === "tables") {
+			let n = N(e.op);
+			if (n === void 0 || !t.tables.has(n)) return e;
+		}
+		let { blocked: n, ...r } = e;
+		return r;
+	})
+}), F = (e, t, n) => t === "postgres" ? c(e, n).pipe(C.flatMap((e) => {
+	let t = l(e);
+	return t === void 0 ? C.void : C.logWarning(`auto-migrate: ${t}`).pipe(C.annotateLogs({ scope: "voltro:migrate" }));
+}), C.catch(() => C.void)) : C.void, I = (i, o, c) => C.gen(function* () {
+	let l = r(i), f = o;
+	if (c.charset === "utf8mb4") {
+		let e = new Set(o.map((e) => e.tableName)), t = S(yield* x(i), e, c.charset);
+		if (!b(t)) {
+			let t = yield* v(i, {
+				declaredNames: e,
+				charset: c.charset
+			});
+			for (let e of y(t)) yield* C.logInfo(`auto-migrate: store charset — ${e}`).pipe(C.annotateLogs({ scope: "voltro:migrate" }));
+		}
+	}
+	let p = yield* h(i);
+	if (!p && process.env.VOLTRO_MIGRATE_FORCE !== "1") {
+		let e = a(s(f, l, { charset: c.charset }));
+		if ((yield* T(i)) === e) return yield* F(i, l, f), {
+			kind: "up-to-date",
+			fingerprint: e
+		};
+	}
+	let g = yield* d(i), _ = yield* A(i, g.tables);
+	_.length > 0 && (yield* C.logInfo(`auto-migrate: reaped ${_.length} test-fixture leftover(s)`).pipe(C.annotateLogs({
+		scope: "voltro:migrate",
+		count: _.length
+	})), g = yield* d(i));
+	{
+		let n = c.softDropRetentionDays ?? 7, r = e(g, { retentionDays: n });
+		r.length > 0 && (yield* C.logWarning(`auto-migrate: ${t(r, n)}`).pipe(C.annotateLogs({
+			scope: "voltro:migrate",
+			snapshots: r.map((e) => e.name)
+		})));
+	}
+	let w = new Set(o.map((e) => e.tableName)), D = (e) => n(e, w), O = { tables: D(g.tables) }, k = u({
+		declared: f,
+		live: O,
+		dialect: l,
+		charset: c.charset,
+		...j()
+	});
+	if (k.summary.blocked > 0) {
+		let e = k.operations.filter((e) => e.blocked).every((e) => e.classification === "lossy"), t = M(process.env.VOLTRO_DESTRUCTIVE_OK);
+		if (t === void 0 || !e || (k = P(k, t), k.operations.some((e) => e.blocked))) return {
+			kind: "refused-blocked",
+			plan: k
+		};
+	}
+	return k.operations.length === 0 && !p ? (yield* E(i, k, {
+		appliedBy: c.appliedBy,
+		environment: c.environment === "prod" ? "dev" : c.environment,
+		source: "auto-diff"
+	}), {
+		kind: "up-to-date",
+		fingerprint: k.toFingerprint
+	}) : {
+		kind: "applied",
+		applied: yield* m(i, k, {
+			...c.beforeExecute === void 0 ? {} : { beforeExecute: c.beforeExecute },
+			declared: o,
+			charset: c.charset,
+			appliedBy: c.appliedBy,
+			environment: c.environment === "prod" ? "dev" : c.environment,
+			source: "auto-diff",
+			replan: (e) => C.gen(function* () {
+				let t = yield* d(e);
+				return u({
+					declared: f,
+					live: { tables: D(t.tables) },
+					dialect: l,
+					charset: c.charset,
+					...j()
+				});
+			})
+		}),
+		plan: k
+	};
+}), L = (e, t, n) => process.env.VOLTRO_AUTO_MIGRATE === "0" ? g(e, t).pipe(C.as({
+	kind: "skipped",
+	reason: "VOLTRO_AUTO_MIGRATE=0"
+})) : n.environment === "prod" ? D(e, t, n).pipe(C.tap((n) => n.kind === "up-to-date" ? g(e, t) : C.void)) : I(e, t, n).pipe(C.tap((n) => n.kind === "applied" || n.kind === "up-to-date" ? g(e, t) : C.void), C.tap((n) => n.kind === "applied" || n.kind === "up-to-date" ? i(t, r(e)) : C.void)), R = (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=${o(e.fingerprint)})`;
+		case "applied": {
+			let t = e.plan.summary;
+			return `auto-migrate: applied ${e.applied.appliedOps} 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=${o(e.applied.fingerprint)}`;
+		}
+		case "prod-mismatch": return `auto-migrate: SCHEMA FINGERPRINT MISMATCH — declared=${o(e.expected)}` + (e.actual ? ` live=${o(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 === "drop-table").map((e) => "table" in e.op ? e.op.table : "").filter(Boolean), i = t.filter((e) => e.op.kind === "add-column").length, a = t.filter((e) => e.op.kind === "drop-column").length, o = t.filter((e) => e.classification === "needs-rename-annotation").length, s = `auto-migrate: REFUSED — ${e.plan.summary.blocked} blocked operation(s):\n` + w(e.plan), c = [""];
+			if (n > 0 && c.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=${r.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.", `      → Set \`VOLTRO_DESTRUCTIVE_OK=${r.join(",")}\` for ONE run — it acknowledges`, "        the data loss for THOSE tables only; every other lossy op in this plan stays blocked.", "        (`VOLTRO_DESTRUCTIVE_OK=1` acknowledges all of them, which is rarely what you mean.)", "      There is deliberately no `dropped()` marker for a TABLE, unlike for a column: a", "      dropped column leaves a slot worth documenting in the declaration, a dropped table", "      leaves nothing — the marker would be a dead entry you must remember to delete.", "  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`)."), i > 0 && c.push(`${i} 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."), a > 0) {
+				let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+				for (let r of e.plan.operations) {
+					let e = "table" in r.op ? r.op.table : void 0;
+					if (e === void 0) continue;
+					let i = r.op.kind === "drop-column" ? r.op.column : r.op.kind === "add-column" ? r.op.column.name : void 0;
+					if (i === void 0) continue;
+					let a = r.op.kind === "drop-column" ? t : r.op.kind === "add-column" ? n : void 0;
+					a !== void 0 && a.set(e, [...a.get(e) ?? [], i]);
+				}
+				let r = [...t.entries()].filter(([e]) => (n.get(e)?.length ?? 0) > 0).map(([e, t]) => `${e}: ${t.join(", ")} gone, ${n.get(e).join(", ")} new`);
+				c.push(`${a} column(s) are missing from your declared schema.`), r.length > 0 && c.push("  → DID YOU RENAME ONE? This plan drops AND adds columns on the same table:", ...r.map((e) => `      ${e}`), "    If so, add `.renamedFrom('<oldName>')` to the NEW column — the planner then emits a", "    RENAME and the data moves with it. Dropping and re-adding loses every value."), c.push("  → If intentional: give the field the `dropped()` marker as its VALUE —", "    `<column>: dropped()` (import it from `@voltro/database`). It is not a method", "    chained onto the column; the slot stays, documenting the hole.", "  → If a typo: restore the field. Data survives until you drop it.");
+			}
+			return o > 0 && c.push(`${o} 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."), c.push("", "See `voltro db plan` for the full machine-readable diff."), s + "\n" + c.join("\n");
+		}
+	}
+};
+//#endregion
+export { R as describeOutcome, M as destructiveScope, T as fetchLastFingerprint, j as ignoreTablesFromEnv, E as recordUpToDate, L as runPlannedMigrations, P as unblockLossy };

package/dist/migrations/branchRehearsal.js

@@ -0,0 +1,122 @@
+import { unblockLossy as e } from "./boot.js";
+//#region src/migrations/branchRehearsal.ts
+var t = (e) => {
+	let t = e.table;
+	if (typeof t == "string") return t;
+	let n = e.from;
+	return typeof n == "string" ? n : void 0;
+}, n = (e) => ({
+	kind: e.op.kind,
+	table: t(e.op),
+	classification: e.classification,
+	reason: e.reason,
+	blockedFix: e.blocked?.fix
+}), r = (e) => e.operations.map(n), i = async (t) => {
+	let i = t.log ?? (() => {}), a = {
+		branchId: t.branchId,
+		mechanism: t.mechanism,
+		branchedTables: t.branchedTables,
+		replayedForeignKeys: t.replayedForeignKeys
+	}, o = [], s = !1, c;
+	try {
+		await t.provision(), s = !0, i(`branch ${t.branchId} provisioned (${t.mechanism}, ${t.branchedTables} table(s), ${t.replayedForeignKeys} foreign key(s))`);
+		let l = await t.fidelityPlan();
+		if (l.operations.length > 0) c = {
+			...a,
+			outcome: "infidelity",
+			operations: o,
+			lossy: o,
+			blocked: o,
+			applied: !1,
+			converged: !1,
+			residual: o,
+			infidelity: r(l)
+		};
+		else {
+			let s = await t.plan(), l = r(s), u = l.filter((e) => e.classification === "lossy"), d = e(s), f = d.operations.filter((e) => e.blocked !== void 0).map(n);
+			if (f.length > 0) c = {
+				...a,
+				outcome: "blocked",
+				operations: l,
+				lossy: u,
+				blocked: f,
+				applied: !1,
+				converged: !1,
+				residual: o,
+				infidelity: o
+			};
+			else if (l.length === 0) c = {
+				...a,
+				outcome: "clean",
+				operations: l,
+				lossy: u,
+				blocked: f,
+				applied: !1,
+				converged: !0,
+				residual: o,
+				infidelity: o
+			};
+			else {
+				await t.apply(d), i(`branch ${t.branchId}: applied ${l.length} operation(s)`);
+				let e = r(await t.replan());
+				c = {
+					...a,
+					outcome: e.length > 0 ? "diverged" : u.length > 0 ? "lossy" : "clean",
+					operations: l,
+					lossy: u,
+					blocked: f,
+					applied: !0,
+					converged: e.length === 0,
+					residual: e,
+					infidelity: o
+				};
+			}
+		}
+	} catch (e) {
+		c = {
+			...a,
+			outcome: "failed",
+			operations: o,
+			lossy: o,
+			blocked: o,
+			applied: !1,
+			converged: !1,
+			residual: o,
+			infidelity: o,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+	let l = !1;
+	if (s && t.keep !== !0) try {
+		await t.teardown(), l = !0;
+	} catch (e) {
+		i(`branch ${t.branchId}: TEARDOWN FAILED — drop it by hand: ${e instanceof Error ? e.message : String(e)}`);
+	}
+	return {
+		...c,
+		tornDown: l
+	};
+}, a = (e) => {
+	switch (e.outcome) {
+		case "clean": return 0;
+		case "lossy": return 2;
+		case "blocked": return 2;
+		case "diverged": return 1;
+		case "infidelity": return 1;
+		case "failed": return 1;
+	}
+}, o = (e) => `    ${e.classification === "lossy" ? "✗" : "•"} ${e.kind}${e.table ? ` ${e.table}` : ""} [${e.classification}]${e.reason ? ` — ${e.reason}` : ""}${e.blockedFix ? `\n        ! ${e.blockedFix}` : ""}`, s = (e) => {
+	let t = [];
+	if (t.push(`branch rehearsal · ${e.branchId} · mechanism ${e.mechanism}`), t.push(`  branched ${e.branchedTables} table(s), replayed ${e.replayedForeignKeys} foreign key(s)`), e.outcome === "failed") t.push(`  FAILED: ${e.error ?? "unknown error"}`);
+	else if (e.outcome === "infidelity") {
+		t.push("  BRANCH IS NOT A FAITHFUL COPY of the parent — the rehearsal proves nothing about your migration."), t.push("  The parent's own schema still differs from the branch by:");
+		for (let n of e.infidelity) t.push(o(n));
+	} else {
+		t.push(`  plan: ${e.operations.length} operation(s), ${e.lossy.length} lossy, ${e.blocked.length} refused`);
+		for (let n of e.operations) t.push(o(n));
+		if (e.lossy.length > 0 && (t.push(""), t.push(`  ⚠ ${e.lossy.length} operation(s) DESTROY DATA. They were executed on the branch (it is`), t.push("    disposable) so they are rehearsed, but production refuses them until you set"), t.push("    VOLTRO_DESTRUCTIVE_OK — naming the tables, not `1`.")), e.blocked.length > 0 && (t.push(""), t.push(`  ${e.blocked.length} operation(s) the planner will not auto-apply anywhere — the plan was NOT executed.`)), e.applied && (t.push(""), t.push(e.converged ? "  ✓ applied on the branch, and the re-plan is EMPTY (the migration converges)." : `  ✗ applied, but the re-plan STILL proposes ${e.residual.length} operation(s) — this migration does not converge:`), !e.converged)) for (let n of e.residual) t.push(o(n));
+	}
+	return t.push(e.tornDown ? `  branch ${e.branchId} torn down.` : `  branch ${e.branchId} KEPT — drop it when you are done.`), t.join("\n");
+};
+//#endregion
+export { a as branchRehearsalExitCode, s as formatBranchRehearsal, i as rehearseMigrationOnBranch, n as rehearsedOperation };

package/dist/migrations/columnEquivalence.js

@@ -0,0 +1,85 @@
+import { indexStorageShape as e } from "../indexStorage.js";
+import { mssqlTextStorageLength as t } from "../mssqlTextStorage.js";
+import { sqlType as n } from "../migrate.js";
+import { normalizeIndexPredicate as r } from "./indexPredicate.js";
+//#region src/migrations/columnEquivalence.ts
+var i = (e, t) => t.name === "id" && e.primaryKey?.length === 1 && e.primaryKey[0] === "id", a = /* @__PURE__ */ new Set(["integer", "bigint"]), o = (e) => a.has(e) ? "numeric" : "text", s = (e) => e.idScheme?.kind === "numeric" ? "numeric" : "text", c = (e) => e.idStorage ?? (b(e) ? "numeric" : "text"), l = (e) => e.idScheme ? s(e) : c(e), u = (e) => e.type === "text" || e.type === "id" && l(e) === "text", d = (e, t) => t && (e.type === "text" || e.type === "id") ? {
+	...e,
+	type: "id",
+	unique: !0,
+	idStorage: l(e)
+} : e.type === "id" ? {
+	...e,
+	idStorage: l(e)
+} : e, f = (e, t, n) => {
+	let r = d(e, n), i = d(t, !1);
+	return n && r.type === "id" && i.type === "id" && r.idStorage === i.idStorage;
+}, p = (e) => e.type !== "raw", m = (e) => ({
+	kind: e.kind,
+	geomKind: e.geomKind.toUpperCase(),
+	srid: e.srid
+}), h = (e, t) => {
+	if (e === void 0 || t === void 0) return e === t;
+	let n = m(e), r = m(t);
+	return n.kind === r.kind && n.geomKind === r.geomKind && n.srid === r.srid;
+}, g = (t) => {
+	let { kind: n, kindOptions: i, ...a } = t, o = {
+		...a,
+		...e(n, i),
+		...t.where === void 0 ? {} : { where: r(t.where) }
+	};
+	return t.expression ? {
+		...o,
+		columns: []
+	} : o;
+}, _ = (e) => {
+	if (typeof e != "object" || !e) return JSON.stringify(e);
+	if (Array.isArray(e)) return `[${e.map(_).join(",")}]`;
+	let t = e;
+	return `{${Object.keys(t).sort().map((e) => `${JSON.stringify(e)}:${_(t[e])}`).join(",")}}`;
+}, v = (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 _(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 _(JSON.parse(o[1]));
+	} catch {}
+	let s = /^convert\(\s*(?:_\w+\s*)?\\?'(.*?)\\?'\s+using\s+[\w]+\s*\)$/i.exec(a);
+	if (s) try {
+		return _(JSON.parse(s[1]));
+	} catch {}
+	if (a.startsWith("{") || a.startsWith("[")) try {
+		return _(JSON.parse(a));
+	} catch {}
+	return /^-?\d+(\.\d+)?$/.test(a) ? String(Number(a)) : a;
+}, y = (e) => {
+	let t = v(e);
+	return t === "1" || t === "true" ? "__BOOL_TRUE__" : t === "0" || t === "false" ? "__BOOL_FALSE__" : t;
+}, b = (e) => typeof e.defaultValue == "string" && /^nextval\(.+::regclass\)$/i.test(e.defaultValue.trim()), x = (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)
+	};
+}, S = (e, r, i) => {
+	if (r === "mssql") {
+		let n = t(e, i);
+		if (n !== void 0) return n;
+	}
+	try {
+		let t = /^N?VARCHAR\((\d+)\)$/i.exec(n(e, r).trim());
+		return t ? Number(t[1]) : void 0;
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { d as canonicalIdColumn, _ as canonicalJson, y as comparableDefault, g as comparableIndex, m as comparableSpatial, s as declaredIdStorage, p as hasComparableType, o as idStorageOfType, b as isPgSequenceDefault, i as isSolePrimaryKeyId, u as isTextStorage, c as liveIdStorage, x as normRef, v as normalizeDefault, S as renderedTextWidth, l as resolvedIdStorage, f as sameIdSpelling, h as sameSpatial };

package/dist/migrations/ddlError.js

@@ -0,0 +1,63 @@
+//#region src/migrations/ddlError.ts
+var e = [
+	"sqlMessage",
+	"code",
+	"errno",
+	"sqlState",
+	"number",
+	"state",
+	"class",
+	"lineNumber",
+	"procName",
+	"serverName",
+	"detail",
+	"hint",
+	"table",
+	"column",
+	"constraint",
+	"position",
+	"routine"
+], t = (t) => {
+	let n = t.cause;
+	for (let t = 0; t < 6 && typeof n == "object" && n; t++) {
+		let t = n;
+		if (e.some((e) => t[e] !== void 0 && t[e] !== null && t[e] !== "")) return t;
+		n = t.cause;
+	}
+	return t.cause ?? {};
+}, n = (e, n, i, a = 400) => {
+	let o = i, s = t(i), c = (e) => {
+		let t = s[e];
+		return t == null || t === "" ? void 0 : String(t);
+	}, l = [
+		"",
+		`═══ ${e} ═══`,
+		`statement: ${n.replace(/\s+/g, " ").slice(0, a)}${n.length > a ? " …" : ""}`,
+		`db.message: ${c("sqlMessage") ?? c("message") ?? o.message ?? "(none)"}`
+	];
+	for (let e of [
+		"code",
+		"errno",
+		"sqlState",
+		"number",
+		"state",
+		"class",
+		"lineNumber",
+		"procName",
+		"serverName",
+		"detail",
+		"hint",
+		"table",
+		"column",
+		"constraint",
+		"position",
+		"routine"
+	]) {
+		let t = c(e);
+		t !== void 0 && l.push(`db.${e}: ${t}`);
+	}
+	let u = r(c("code"));
+	return u !== void 0 && l.push("", u), l.push(""), l.join("\n");
+}, r = (e) => e === "3F000" ? "remedy: the connection's search_path names a schema that does not exist. Voltro sets it from DB_SCHEMA — create the schema (`CREATE SCHEMA \"<name>\"`) or unset DB_SCHEMA to use the connection default. Voltro creates TABLES, never the schema itself: that is a namespace decision, and inventing one from a typo is how a migration lands somewhere nobody is looking." : void 0;
+//#endregion
+export { n as formatDdlError };

package/dist/migrations/declaredSchema.js

@@ -0,0 +1,162 @@
+import { validateIndexName as e } from "../identifierLimits.js";
+import { isSqliteFamily as t } from "../dialect.js";
+import { encodeSqliteDecimalDefault as n, sqliteDecimalStorageShape as r } from "../sqliteDecimalStorage.js";
+import { isStagingTableName as i } from "./frameworkLiveTables.js";
+import { indexKindForDialect as a, indexStorageShape as o, resolveHnswOptions as s } from "../indexStorage.js";
+import { lowerUniqueActive as c } from "./uniqueActiveLowering.js";
+import { renderedTextWidth as l } from "./columnEquivalence.js";
+import { stampDeclaredCharset as u } from "./storeCharset.js";
+//#region src/migrations/declaredSchema.ts
+var d = (e, i, a) => {
+	let o = i.references ? {
+		table: i.references().tableName,
+		column: i.referenceColumn ?? "id",
+		...i.onDelete ? { onDelete: i.onDelete } : {},
+		...i.refOnUpdate ? { onUpdate: i.refOnUpdate } : {},
+		...i.orphanPolicy ? { orphanPolicy: i.orphanPolicy } : {}
+	} : void 0, s = a === void 0 || t(a) ? r(i) : void 0, c = s ? n(i.defaultValue, s) : i.defaultValue;
+	return {
+		name: e,
+		type: i.type,
+		nullable: i.generatedAs ? !0 : i.nullable,
+		unique: i.unique,
+		hasDefault: i.hasDefault,
+		...i.hasDefault && c !== void 0 ? { defaultValue: c } : {},
+		...o ? { references: o } : {},
+		...i.type === "reference" ? { referenceStorage: i.referenceStorage ?? "text" } : {},
+		...i.oneOf && i.oneOf.length > 0 ? { oneOf: i.oneOf } : {},
+		...i.idScheme ? { idScheme: { kind: i.idScheme.kind } } : {},
+		...i.rawDdl === void 0 ? {} : { rawDdl: i.rawDdl },
+		...i.type === "array" && a !== void 0 && a !== "postgres" ? { storageType: a === "mysql" || a === "mariadb" ? "json" : "text" } : {},
+		...i.type === "enum" && (a === "mssql" || a === "sqlite" || a === "turso") ? { storageType: "text" } : {},
+		...i.type === "enum" && i.enumValues !== void 0 && i.enumValues.length > 0 && (a === "mssql" || a === "sqlite" || a === "turso") ? { oneOf: i.enumValues } : {},
+		...i.maxLength === void 0 ? {} : { maxLength: i.maxLength },
+		...i.precision === void 0 ? {} : { precision: i.precision },
+		...i.scale === void 0 ? {} : { scale: i.scale },
+		...(a === void 0 || t(a)) && i.sqliteDecimalEncoding !== void 0 ? { sqliteDecimalEncoding: i.sqliteDecimalEncoding } : {},
+		...i.generatedAs ? { generatedAs: {
+			expr: i.generatedAs.expr,
+			stored: i.generatedAs.stored
+		} } : {},
+		...i.narrowedFrom ? { narrowedFrom: {
+			from: i.narrowedFrom.from,
+			...i.narrowedFrom.using === void 0 ? {} : { using: i.narrowedFrom.using }
+		} } : {},
+		...i.sensitive ? { sensitive: i.sensitive } : i.encrypted && !i.safe ? { sensitive: { class: "secret" } } : {},
+		...i.safe ? { safe: !0 } : {},
+		...i.vectorDim === void 0 ? {} : { vectorDim: i.vectorDim },
+		...i.vectorPrecision === void 0 ? {} : { vectorPrecision: i.vectorPrecision },
+		...i.arrayElement === void 0 ? {} : { arrayElement: i.arrayElement },
+		...i.enumName !== void 0 && (a === void 0 || a === "postgres") ? { enumName: i.enumName } : {},
+		...i.enumValues === void 0 ? {} : { enumValues: i.enumValues },
+		...i.spatial === void 0 ? {} : { spatial: i.spatial }
+	};
+}, f = (t, n) => {
+	let r = [], i = /* @__PURE__ */ new Set(), c = (e) => {
+		i.has(e.name) || (i.add(e.name), r.push(e));
+	}, l = t.appliedPrimaryKey ?? [];
+	l.length > 0 ? c({
+		name: `${t.tableName}_pkey`,
+		table: t.tableName,
+		columns: [...l],
+		unique: !0
+	}) : t.fields.id && c({
+		name: `${t.tableName}_pkey`,
+		table: t.tableName,
+		columns: ["id"],
+		unique: !0
+	});
+	let u = t.appliedIndexes ?? [];
+	for (let e of u) {
+		let r = a(e.kind, n);
+		if (r === null) continue;
+		let i = e.fields[0], l = typeof i == "string" ? t.fields[i]?.vectorPrecision : void 0, u = r === "hnsw" ? { hnsw: s(e.kindOptions, l) } : r === "gin" ? e.kindOptions : void 0, d = e.fields.map((e) => typeof e == "string" ? e : "jsonPath" in e ? `(json:${e.jsonPath.column}->${e.jsonPath.path.join(".")}${e.jsonPath.numeric ? "::num" : ""})` : `(${e.expr})`), f = e.fields.some((e) => typeof e != "string");
+		c({
+			name: e.name,
+			table: t.tableName,
+			columns: d,
+			unique: e.unique ?? !1,
+			...o(r, u),
+			...e.where === void 0 ? {} : { where: e.where },
+			...f ? { expression: !0 } : {}
+		});
+	}
+	let d = t.appliedUniques ?? [];
+	for (let e of d) e.fields.length < 2 || c({
+		name: e.name,
+		table: t.tableName,
+		columns: e.fields,
+		unique: !0
+	});
+	let f = /* @__PURE__ */ new Set();
+	for (let e of u) e.fields.every((e) => typeof e == "string") && f.add(e.fields.join("\0"));
+	for (let [n, r] of Object.entries(t.fields)) {
+		let i = r;
+		if (i.dropped || !i.references || i.fkAutoIndex === !1 || f.has(n)) continue;
+		let a = `${t.tableName}_${n}_idx`;
+		e(t.tableName, a, !0, [n]), c({
+			name: a,
+			table: t.tableName,
+			columns: [n],
+			unique: !1
+		});
+	}
+	return r;
+}, p = (e, t) => {
+	let n = new Set((e.appliedUniques ?? []).filter((e) => e.fields.length === 1).map((e) => e.fields[0])), r = [];
+	for (let [i, a] of Object.entries(e.fields)) {
+		if (a.dropped) continue;
+		let e = d(i, a, t);
+		r.push(n.has(i) ? {
+			...e,
+			unique: !0
+		} : e);
+	}
+	let i = e.appliedPrimaryKey ?? [], a = e.previousTableName;
+	return {
+		name: e.tableName,
+		columns: r,
+		indexes: f(e, t),
+		...i.length > 0 ? { primaryKey: [...i] } : {},
+		...a === void 0 ? {} : { renamedFrom: a }
+	};
+}, m = (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);
+	}
+}, h = (e, t, n = {}) => {
+	if (n.charset !== void 0 && t !== "mysql" && t !== "mariadb") throw Error(`store charset '${n.charset}' is declared for a ${t ?? "dialect-less"} store — a character set is a MySQL / MariaDB setting. Remove \`charset\` from \`store\` in app.config.ts, or declare \`store: { dialect: 'mysql' | 'mariadb', charset }\`.`);
+	let r = e.filter((e) => !i(e.tableName)).map((e) => p(c(e, t), t));
+	if (t === "mysql" || t === "mariadb") {
+		for (let e of r) for (let n of e.indexes) if (n.where !== void 0) throw Error(`Partial index '${n.name}' on '${e.name}' is not supported by ${t}. Use uniqueActive for portable conditional uniqueness.`);
+	}
+	m(r);
+	let a = t === void 0 ? r : r.map((e) => g(e, t));
+	return { tables: n.charset === void 0 ? a : u(a, n.charset) };
+}, g = (e, n) => {
+	let r = new Set(e.indexes.flatMap((e) => e.columns));
+	return {
+		...e,
+		columns: e.columns.map((e) => {
+			if (n === "mssql" && !e.generatedAs && (e.type === "json" || e.type === "array") && (e = {
+				...e,
+				jsonValidation: e.type === "json" ? "value" : "container"
+			}), t(n)) {
+				if (e.maxLength === void 0) return e;
+				let { maxLength: t, ...n } = e;
+				return n;
+			}
+			if (e.maxLength !== void 0) return e;
+			let i = l(e, n, r.has(e.name) || e.unique);
+			return i === void 0 ? e : {
+				...e,
+				maxLength: i
+			};
+		})
+	};
+};
+//#endregion
+export { h as declaredSnapshot, d as snapshotColumn };

package/dist/migrations/deployLedger.js

@@ -0,0 +1,19 @@
+import { id as e, text as t } from "../columns.js";
+import { table as n } from "../table.js";
+import { Effect as r } from "effect";
+//#region src/migrations/deployLedger.ts
+var i = "_voltro_deploys", a = n(i, {
+	id: e({ prefix: "dpl" }),
+	status: t(),
+	dialect: t(),
+	appliedBy: t(),
+	startedAt: t(),
+	baseline: t(),
+	report: t().nullable()
+}), o = (e, t) => e`INSERT INTO ${e(i)} (${e("id")}, ${e("status")}, ${e("dialect")}, ${e("appliedBy")}, ${e("startedAt")}, ${e("baseline")}, ${e("report")})
+      VALUES (${t.id}, ${"running"}, ${t.dialect}, ${t.appliedBy}, ${(/* @__PURE__ */ new Date()).toISOString()}, ${t.baseline}, ${null})`.pipe(r.asVoid), s = (e, t) => e`DELETE FROM ${e(i)} WHERE ${e("id")} = ${t}`.pipe(r.asVoid), c = (e, t, n) => e`UPDATE ${e(i)} SET ${e("status")} = ${"failed"}, ${e("report")} = ${n} WHERE ${e("id")} = ${t}`.pipe(r.asVoid), l = (e) => e`SELECT ${e("id")}, ${e("status")}, ${e("dialect")}, ${e("appliedBy")}, ${e("startedAt")}, ${e("baseline")}, ${e("report")} FROM ${e(i)}`.pipe(r.map((e) => e.map((e) => ({
+	...e,
+	startedAt: String(e.startedAt)
+}))), r.catch(() => r.succeed([])));
+//#endregion
+export { i as DEPLOY_LEDGER_TABLE, a as _voltroDeploysTable, s as closeDeploy, c as failDeploy, o as openDeploy, l as unfinishedDeploys };