@voltro/database 0.85.0 → 0.86.0

package/dist/migrations/sqliteDecimalSource.js

@@ -0,0 +1,69 @@
+import { encodeSqliteDecimal as e } from "../sqliteDecimal.js";
+import { sqlError as t } from "../sqlError.js";
+import { readSqliteTableSchema as n } from "./sqliteTableSchema.js";
+import { Effect as r } from "effect";
+//#region src/migrations/sqliteDecimalSource.ts
+var i = (e) => `CASE WHEN typeof(${e}) IN ('text','blob') THEN hex(${e}) ELSE quote(${e}) END`, a = (a, o, c, l, u) => r.gen(function* () {
+	let d = (e) => r.fail(t(e));
+	if (c.length === 0 || new Set(c).size !== c.length || new Set(l.map((e) => e.name)).size !== l.length) return yield* d("Decimal source requires distinct key and conversion columns");
+	yield* n(a, o);
+	let f = yield* a.executeUnprepared(`PRAGMA main.table_xinfo(${s(o)})`, [], void 0);
+	if ([...c, ...l.map((e) => e.name)].some((e) => !f.some((t) => t.name === e))) return yield* d("Decimal source columns do not match the retained table");
+	yield* r.try({
+		try: () => l.forEach((t) => {
+			e("0", t.target), typeof t.source != "string" && e("0", t.source.shape);
+		}),
+		catch: (e) => t("Invalid decimal source or target shape", e)
+	});
+	let p = c.flatMap((e, t) => [`typeof(${s(e)}) AS ${s(`k${t}t`)}`, `${i(s(e))} AS ${s(`k${t}v`)}`]);
+	l.forEach((e, t) => {
+		p.push(`typeof(${s(e.name)}) AS ${s(`c${t}t`)}`), p.push(`${e.source === "numeric" ? `CASE WHEN ${s(e.name)} IS NULL THEN NULL ELSE quote(${s(e.name)}) END` : `CAST(${s(e.name)} AS TEXT)`} AS ${s(`c${t}v`)}`);
+	});
+	let m = c.flatMap((e, t) => [`k${t}t`, `k${t}v`]), h = m.map((e) => `${s(e)} COLLATE BINARY`).join(", "), g = `SELECT ${p.join(", ")} FROM main.${s(o)}`, _, v;
+	for (;;) {
+		let e = _ === void 0 ? 256 : 257, t = _ === void 0 ? "" : ` WHERE (${h}) >= (${m.map(() => "?").join(", ")})`, n = yield* a.executeUnprepared(`SELECT * FROM (${g}) AS observed${t} ORDER BY ${h} LIMIT ${e}`, _ ?? [], void 0);
+		if (_ !== void 0 && (n.length === 0 || m.some((e, t) => n[0][e] !== _[t]))) return yield* d("Retained decimal source changed during paged observation");
+		let r = [];
+		for (let e of n.slice(_ === void 0 ? 0 : 1)) {
+			let t = JSON.stringify(c.map((t, n) => [
+				t,
+				e[`k${n}t`],
+				e[`k${n}v`]
+			]));
+			if (t === v) return yield* d("Retained source has ambiguous row identities");
+			v = t;
+			for (let [n, i] of l.entries()) {
+				let a = e[`c${n}t`], o = e[`c${n}v`] ?? null;
+				if (a !== "null" && !(i.source === "numeric" ? a === "integer" || a === "real" : a === "text")) return yield* d("Retained decimal storage class does not match its reviewed source kind");
+				r.push({
+					rowIdentity: t,
+					column: i.name,
+					target: i.target,
+					source: typeof i.source == "string" ? {
+						kind: i.source,
+						value: o
+					} : {
+						kind: "sortable-v1",
+						value: o,
+						shape: i.source.shape
+					}
+				});
+			}
+		}
+		if (r.length > 0 && (yield* u(r)), n.length < e) break;
+		let i = n[n.length - 1], o = [];
+		for (let e of m) {
+			let t = i[e];
+			if (typeof t != "string") return yield* d("Retained source key projection is not an exact SQL value");
+			o.push(t);
+		}
+		_ = o;
+	}
+}), o = (e, t, n, i) => r.gen(function* () {
+	let o = [];
+	return yield* a(e, t, n, i, (e) => r.sync(() => {
+		for (let t of e) o.push(t);
+	})), o;
+}), s = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"";
+//#endregion
+export { a as forEachSqliteDecimalSourcePage, o as readSqliteDecimalSource, i as sqliteDecimalKeyValueSql };

package/dist/migrations/sqliteDecimalStage.js

@@ -0,0 +1,135 @@
+import { encodeSqliteDecimal as e } from "../sqliteDecimal.js";
+import { sqliteDecimalStorageShape as t } from "../sqliteDecimalStorage.js";
+import { sqlError as n } from "../sqlError.js";
+import { assertSqliteForeignKeys as r } from "./sqliteForeignKeys.js";
+import { runSqliteMigrationStatement as i } from "./sqliteMigrationBatch.js";
+import { withMigrationTransaction as a } from "./transactionCause.js";
+import { emitCreateTableSqlite as o } from "./applier.js";
+import { assertSqliteTableSchema as s, sqliteTableSchemaMatchesSql as c } from "./sqliteTableSchema.js";
+import { sqliteDecimalKeyValueSql as l } from "./sqliteDecimalSource.js";
+import { restoreSqliteSequenceSql as u } from "./sqliteRowIdentity.js";
+import { assertSqliteSnapshot as d } from "./sqliteSnapshotGuard.js";
+import { readSqliteSchemaEpoch as f, sqliteSchemaEpochMatchesSql as p } from "./sqliteSchemaEpoch.js";
+import { sqliteWitnessProtectionStatements as m } from "./sqliteWitnessProtection.js";
+import { forEachSqliteDecimalReviewRow as h } from "./sqliteDecimalReviewStore.js";
+import { prepareSqliteRetainedSource as g } from "./sqliteRetainedSource.js";
+import { Effect as _, Option as v } from "effect";
+import { SqlClient as y } from "effect/sql";
+//#region src/migrations/sqliteDecimalStage.ts
+var b = (b, T, E) => _.gen(function* () {
+	let y = (e) => _.fail(n(e)), D = T.decimalReview;
+	if (!D || D.columns.length === 0 || E.name !== T.source) return yield* y("Decimal stage requires complete reviewed cells and the matching target table");
+	let O = yield* _.try({
+		try: () => {
+			let n = E.columns.map((n) => {
+				let r = t(n), i = D.columns.find((e) => e.name === n.name);
+				if (r === void 0) {
+					if (i) throw TypeError("Reviewed decimal column has no encoded target");
+					return n;
+				}
+				if (!i || i.target.precision !== r.precision || i.target.scale !== r.scale) throw TypeError("Decimal target shape does not match the review");
+				if (!n.hasDefault || n.defaultValue === null) return n;
+				if (typeof n.defaultValue != "string") throw TypeError("Decimal target default requires an exact string");
+				return {
+					...n,
+					defaultValue: e(n.defaultValue, r)
+				};
+			});
+			if (D.columns.some((e) => !E.columns.some((t) => t.name === e.name))) throw TypeError("Reviewed column is absent from the target");
+			if (E.indexes.some((e) => e.expression || e.kind && e.kind !== "btree")) throw TypeError("Decimal stage cannot silently simplify an expression or specialized index");
+			return { columns: n };
+		},
+		catch: (e) => n("Invalid reviewed decimal target", e)
+	}), k = yield* g(b, T), A = k.reviewStore;
+	if (A === null) return yield* y("Decimal stage requires an owned review store");
+	let j = yield* _.scoped(_.gen(function* () {
+		let e = yield* b.reserve, t = yield* f(e);
+		return yield* d(e, k.copy, k.contents, k.rowIdentity), t;
+	})), M = `${k.marker}_stage`, N = `${k.marker}_stage_owner`, P = `${k.marker}_stage_guard`, F = E.indexes.filter((e) => e.name !== `${E.name}_pkey`).map((e, t) => ({
+		...e,
+		table: M,
+		name: `${M}_index_${t}`
+	})), I = o({
+		kind: "create-table",
+		table: M,
+		columns: O.columns,
+		indexes: F,
+		...E.primaryKey ? { primaryKey: E.primaryKey } : {}
+	}).map((e) => e.replace(/ IF NOT EXISTS /, " ")), L = O.columns.filter((e) => !e.generatedAs), R = k.rowIdentity.alias;
+	if (R !== null && O.columns.some((e) => e.name.toLowerCase() === R)) return yield* y("Target shadows the retained rowid alias");
+	if (k.rowIdentity.autoincrement && !O.columns.some((e) => e.idScheme?.kind === "numeric")) return yield* y("Target must preserve source AUTOINCREMENT allocation");
+	let z = (e, { identity: t, values: n }) => {
+		let r = JSON.parse(t), i = (e, t) => w(r.map(([r, i, a]) => {
+			let o = `${e}.${x(r)}`;
+			return t && n.has(r) ? `${o} COLLATE BINARY IS ${C(n.get(r))}` : `typeof(${o}) = ${S(i)} AND ${l(o)} COLLATE BINARY = ${S(a)}`;
+		})), a = i("c", !1);
+		if (e === "insert") return `INSERT INTO ${x(M)} (${[...R === null ? [] : [x(R)], ...L.map((e) => x(e.name))].join(", ")}) SELECT ${R === null ? "" : `c.${x(R)}, `}${L.map((e) => n.has(e.name) ? C(n.get(e.name)) : `c.${x(e.name)}`).join(", ")} FROM main.${x(k.copy)} c WHERE ${a}`;
+		let o = O.columns.map((e) => {
+			let t = x(e.name);
+			return n.has(e.name) ? `s.${t} COLLATE BINARY IS ${C(n.get(e.name))}` : `(typeof(s.${t}) = typeof(c.${t}) AND s.${t} COLLATE BINARY IS c.${t} COLLATE BINARY)`;
+		});
+		return R !== null && o.push(`s.${x(R)} IS c.${x(R)}`), `(SELECT COUNT(*) FROM main.${x(M)} s, main.${x(k.copy)} c WHERE ${a} AND ${i("s", !0)} AND ${w(o)}) = 1`;
+	}, B = (e) => _.gen(function* () {
+		let t = [], n = 0, r = (t) => _.gen(function* () {
+			if ((yield* e.executeUnprepared(`SELECT 1 WHERE NOT (${t})`, [], void 0)).length > 0) return yield* y("Decimal stage rows no longer match the reviewed conversion");
+		});
+		yield* h(A, (e) => _.gen(function* () {
+			t.push(z("match", e)), n++, t.length === 32 && (yield* r(w(t)), t = []);
+		})), t.length > 0 && (yield* r(w(t))), yield* r(w([`(SELECT COUNT(*) FROM main.${x(M)}) = ${n}`, c(k.copy, k.witnessSchema)]));
+	}), V = JSON.stringify({
+		version: 2,
+		sourceOwner: k.marker,
+		target: E,
+		review: A.witness
+	}), H = `CREATE TABLE ${x(N)} (manifest TEXT NOT NULL, schema TEXT NOT NULL)`, U = yield* b.unsafe("SELECT sql FROM main.sqlite_master WHERE name = ? COLLATE NOCASE", [N]);
+	if (U.length === 0) yield* a(b, _.gen(function* () {
+		let e = yield* _.serviceOption(b.transactionService);
+		if (v.isNone(e)) return yield* y("Decimal stage requires a pinned transaction connection");
+		let t = e.value[0];
+		yield* i(t, `CREATE TABLE ${x(P)} (valid INTEGER CHECK(valid = 1))`), yield* i(t, `INSERT INTO ${x(P)} SELECT CASE WHEN ${p(j, 1)} THEN 1 ELSE 0 END`), yield* i(t, H);
+		for (let e of I) yield* i(t, e);
+		yield* h(A, (e) => i(t, z("insert", e)));
+		for (let e of u(M, k.rowIdentity)) yield* i(t, e);
+		yield* B(t), yield* i(t, `DROP TABLE ${x(P)}`);
+		for (let e of m(M, N)) yield* i(t, e);
+		if (yield* i(t, `INSERT INTO ${x(N)} SELECT ${S(V)}, json_group_array(json_object('type',type,'name',name,'sql',sql)) FROM (SELECT type,name,sql FROM main.sqlite_master WHERE tbl_name = ${S(M)} AND type IN ('table','index','trigger') ORDER BY type COLLATE BINARY,name COLLATE BINARY)`), (yield* t.executeUnprepared("PRAGMA foreign_key_check", [], void 0)).length > 0) return yield* y("Decimal stage would leave invalid foreign key references");
+		yield* r(t);
+	}));
+	else {
+		if (U.length !== 1 || U[0]?.sql !== H) return yield* y("Decimal stage marker is not owned by this conversion");
+		let e = yield* b.unsafe(`SELECT manifest FROM main.${x(N)}`);
+		if (e.length !== 1 || e[0]?.manifest !== V) return yield* y("Decimal stage identity does not match the reviewed conversion");
+	}
+	let W = yield* b.unsafe(`SELECT schema FROM main.${x(N)}`), G = yield* _.try({
+		try: () => ({ objects: JSON.parse(W[0].schema) }),
+		catch: (e) => n("Invalid retained decimal stage schema witness", e)
+	}), K = yield* a(b, _.gen(function* () {
+		let e = yield* _.serviceOption(b.transactionService);
+		if (v.isNone(e)) return yield* y("Decimal stage validation requires a pinned transaction");
+		let t = e.value[0], n = yield* f(t);
+		return yield* d(t, k.copy, k.contents, k.rowIdentity), yield* B(t), yield* s(t, M, G), yield* s(t, T.source, T.reviewedSchema), n;
+	}));
+	return {
+		stage: M,
+		marker: N,
+		sourceCopy: k.copy,
+		sourceMarker: k.marker,
+		sourceManifest: k.manifest,
+		sourceContents: k.contents,
+		sourceRowIdentity: k.rowIdentity,
+		manifest: V,
+		schema: G,
+		validationEpoch: K,
+		indexes: F.map((e) => e.name)
+	};
+}).pipe(_.provideService(y.SqlClient, b)), x = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", S = (e) => "'" + e.replaceAll("'", "''") + "'", C = (e) => e === null ? "NULL" : S(e), w = (e) => {
+	let t = (n, r) => {
+		if (n === r) return "1";
+		if (r - n === 1) return `(${e[n]})`;
+		let i = n + Math.floor((r - n) / 2);
+		return `(${t(n, i)} AND ${t(i, r)})`;
+	};
+	return t(0, e.length);
+};
+//#endregion
+export { b as prepareSqliteDecimalStage };

package/dist/migrations/sqliteForeignKeys.js

@@ -0,0 +1,38 @@
+import { sqlError as e } from "../sqlError.js";
+import { Effect as t } from "effect";
+//#region src/migrations/sqliteForeignKeys.ts
+var n = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", r = (e) => e.replace(/[A-Z]/g, (e) => e.toLowerCase()), i = (i) => t.gen(function* () {
+	let a = (e) => i.executeUnprepared(e, [], void 0), o = () => t.fail(e("SQLite schema rewrite would leave invalid foreign key references")), s = yield* a("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"), c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+	for (let { name: e } of s) {
+		let t = yield* a(`PRAGMA main.foreign_key_list(${n(e)})`), i = /* @__PURE__ */ new Map();
+		for (let e of t) {
+			let t = i.get(e.id);
+			t === void 0 ? i.set(e.id, [e]) : t.push(e);
+		}
+		for (let t of i.values()) {
+			let i = t.toSorted((e, t) => e.seq - t.seq), s = i[0].table, u = r(s), d = c.get(u);
+			if (d === void 0) {
+				let e = yield* a(`PRAGMA main.table_info(${n(s)})`);
+				d = {
+					columns: e,
+					primary: e.filter((e) => e.pk > 0).toSorted((e, t) => e.pk - t.pk).map((e) => e.name)
+				}, c.set(u, d);
+			}
+			let { columns: f, primary: p } = d, m = i.map((e, t) => e.to ?? p[t]);
+			if (i.some((e) => e.to === null) && p.length !== i.length || m.some((e) => e === void 0 || !f.some((t) => r(t.name) === r(e)))) return yield* o();
+			let h = m.filter((e) => e !== void 0), g = (e) => e.length === h.length && e.every((e) => h.some((t) => r(t) === r(e))), _ = g(p);
+			!_ && d.indexes === void 0 && (d.indexes = yield* a(`PRAGMA main.index_list(${n(s)})`));
+			let v = _ ? [] : d.indexes;
+			for (let e of v) {
+				if (_ || e.unique !== 1 || e.partial !== 0) continue;
+				let t = r(e.name), i = l.get(t);
+				i === void 0 && (i = yield* a(`PRAGMA main.index_info(${n(e.name)})`), l.set(t, i)), _ = i.every((e) => e.name !== null) && g(i.map((e) => e.name));
+			}
+			if (!_) return yield* o();
+			let y = i.map((e) => `child.${n(e.from)} IS NOT NULL`).join(" AND "), b = i.map((e, t) => `parent.${n(h[t])} = child.${n(e.from)}`).join(" AND ");
+			if ((yield* a(`SELECT 1 FROM main.${n(e)} AS child WHERE ${y} AND NOT EXISTS (SELECT 1 FROM main.${n(s)} AS parent WHERE ${b}) LIMIT 1`)).length > 0) return yield* o();
+		}
+	}
+});
+//#endregion
+export { i as assertSqliteForeignKeys };

package/dist/migrations/sqliteMigrationBatch.js

@@ -0,0 +1,37 @@
+import { sqlError as e } from "../sqlError.js";
+import { dialectOf as t } from "./resumeLedger.js";
+import { assertSqliteForeignKeys as n } from "./sqliteForeignKeys.js";
+import { Effect as r, Option as i } from "effect";
+import { randomUUID as a } from "node:crypto";
+//#region src/migrations/sqliteMigrationBatch.ts
+var o = (t, n) => r.try({
+	try: () => t.executeUnprepared(n, [], void 0),
+	catch: (t) => e("Failed to prepare SQLite migration statement", t)
+}).pipe(r.flatten, r.asVoid), s = /* @__PURE__ */ new WeakMap(), c = (e, t) => {
+	s.set(e, t);
+}, l = (e) => {
+	let t = "\"__voltro_migration_guard_" + a().replaceAll("-", "") + "\"";
+	return [
+		...e,
+		`CREATE TABLE ${t} (valid INTEGER CHECK (valid = 1))`,
+		`INSERT INTO ${t} SELECT 0 FROM pragma_foreign_key_check`,
+		`DROP TABLE ${t}`
+	];
+}, u = (a, c) => r.gen(function* () {
+	if (c.length === 0) return;
+	let l = t(a);
+	if (l !== "sqlite" && l !== "turso") return yield* r.fail(e("SQLite migration batches require a SQLite-family client"));
+	if (i.isSome(yield* r.serviceOption(a.transactionService))) return yield* r.fail(e("SQLite schema rewrites must run outside an enclosing transaction"));
+	let u = s.get(a);
+	return u ? yield* u(c) : yield* r.scoped(r.gen(function* () {
+		let t = yield* a.reserve, i = (e) => o(t, e), s = i(`PRAGMA foreign_keys=${(yield* t.executeUnprepared("PRAGMA foreign_keys", [], void 0))[0]?.foreign_keys === 0 ? "OFF" : "ON"}`);
+		yield* r.acquireUseRelease(i("PRAGMA foreign_keys=OFF"), () => r.acquireUseRelease(i("BEGIN IMMEDIATE").pipe(r.as({ committed: !1 })), (a) => r.gen(function* () {
+			if (yield* r.forEach(c, i, { discard: !0 }), (yield* t.executeUnprepared("PRAGMA foreign_key_check", [], void 0)).length > 0) return yield* r.fail(e("SQLite schema rewrite would leave invalid foreign key references"));
+			yield* n(t), yield* r.uninterruptible(i("COMMIT").pipe(r.tap(() => r.sync(() => {
+				a.committed = !0;
+			}))));
+		}), (e) => e.committed ? r.void : i("ROLLBACK").pipe(r.orDie)), () => s.pipe(r.orDie));
+	}));
+});
+//#endregion
+export { c as registerSqliteMigrationBatch, u as runSqliteMigrationBatch, o as runSqliteMigrationStatement, l as sqliteMigrationBatchStatements };

package/dist/migrations/sqliteRetainedSource.js

@@ -0,0 +1,106 @@
+import { sqlError as e } from "../sqlError.js";
+import { dialectOf as t } from "./resumeLedger.js";
+import { runSqliteMigrationStatement as n } from "./sqliteMigrationBatch.js";
+import { withMigrationTransaction as r } from "./transactionCause.js";
+import { assertSqliteTableSchema as i, readSqliteTableSchema as a } from "./sqliteTableSchema.js";
+import { assertSqliteRowIdentity as o, readSqliteRowIdentity as s } from "./sqliteRowIdentity.js";
+import { assertSqliteTableContents as c, readSqliteTableContents as l } from "./sqliteTableContents.js";
+import { sqliteDecimalReviewInputWitness as u } from "./sqliteDecimalReviewWitness.js";
+import { sqliteWitnessProtectionStatements as d } from "./sqliteWitnessProtection.js";
+import { importSqliteDecimalReview as f, reopenSqliteDecimalReview as p, verifySqliteDecimalReviewCoverage as m } from "./sqliteDecimalReviewStore.js";
+import { assertSqliteTableCopy as h } from "./sqliteTableCopy.js";
+import { Effect as g, Option as _ } from "effect";
+import { createHash as v } from "node:crypto";
+import { SqlClient as y } from "effect/sql";
+//#region src/migrations/sqliteRetainedSource.ts
+var b = (e) => {
+	let t = `_voltro_review_${v("sha256").update(JSON.stringify([e.migrationId, e.source])).digest("hex")}`;
+	return {
+		table: t,
+		marker: `${t}_owner`
+	};
+}, x = (e) => {
+	let t = `_voltro_source_${v("sha256").update(JSON.stringify([e.migrationId, e.source])).digest("hex")}`;
+	return {
+		marker: t,
+		copy: `${t}_rows`
+	};
+}, S = (v, S) => g.gen(function* () {
+	let y = (t) => g.fail(e(t));
+	return _.isSome(yield* g.serviceOption(v.transactionService)) ? yield* y("Retained source preparation must run outside an enclosing transaction") : ["sqlite", "turso"].includes(t(v)) ? yield* r(v, g.gen(function* () {
+		let t = yield* g.serviceOption(v.transactionService);
+		if (_.isNone(t)) return yield* y("Retained source preparation requires a pinned transaction connection");
+		let r = t.value[0];
+		if (!S.migrationId || !S.source || !S.targetIdentity) return yield* y("Retained source requires migration, source and target identities");
+		let { marker: T, copy: E } = x(S), D = `CREATE TABLE ${C(T)} (manifest TEXT NOT NULL, schema TEXT NOT NULL)`, O = yield* v.unsafe("SELECT sql FROM main.sqlite_master WHERE name = ? COLLATE NOCASE", [T]), k = null;
+		if (S.decimalReview !== void 0) {
+			let t = S.decimalReview, n = b(S), r = yield* g.try({
+				try: () => u(t.cells),
+				catch: (t) => e("Invalid explicit decimal conversion review", t)
+			});
+			if (O.length === 0) {
+				if (k = yield* f(n.table, T, t.cells), JSON.stringify(k.witness) !== JSON.stringify(r)) return yield* y("Decimal review input changed between reads; provide a repeatable canonical iterable");
+			} else k = yield* p(n.table, T, r);
+		}
+		let A = (e) => g.gen(function* () {
+			if (S.decimalReview === void 0 || k === null) return null;
+			let t = S.decimalReview;
+			return yield* m(k, e, t.keys, t.columns), k.witness;
+		}), j = yield* g.scoped(g.gen(function* () {
+			return yield* i(r, S.source, S.reviewedSchema), {
+				rowIdentity: yield* s(r, S.source),
+				decimalReview: yield* A(S.source),
+				contents: yield* l(r, S.source)
+			};
+		})), M = JSON.stringify({
+			version: 1,
+			migrationId: S.migrationId,
+			source: S.source,
+			targetIdentity: S.targetIdentity,
+			reviewedSchema: S.reviewedSchema,
+			...j,
+			copy: E,
+			...k === null ? {} : { reviewArtifact: {
+				table: k.table,
+				marker: k.marker,
+				manifest: k.manifest
+			} }
+		});
+		if (O.length > 0) {
+			if (O.length !== 1 || O[0]?.sql !== D) return yield* y("Retained source marker is not owned by this conversion");
+			let e = yield* v.unsafe(`SELECT manifest FROM main.${C(T)}`);
+			if (e.length !== 1 || e[0]?.manifest !== M) return yield* y("Retained source identity or reviewed schema does not match this conversion");
+		} else {
+			let e = [...j.rowIdentity.alias === null ? [] : [j.rowIdentity.alias], ...j.contents.columns].map(C).join(", ");
+			yield* g.forEach([
+				D,
+				`CREATE TABLE ${C(E)} AS SELECT * FROM main.${C(S.source)} WHERE 0`,
+				`INSERT INTO ${C(E)} (${e}) SELECT ${e} FROM main.${C(S.source)}`,
+				...d(E, T),
+				`INSERT INTO ${C(T)} SELECT ${w(M)}, json_group_array(json_object('type',type,'name',name,'sql',sql)) FROM (SELECT type,name,sql FROM main.sqlite_master WHERE tbl_name = ${w(E)} AND type IN ('table','index','trigger') ORDER BY type COLLATE BINARY,name COLLATE BINARY)`
+			], (e) => n(r, e), { discard: !0 });
+		}
+		let N = yield* v.unsafe(`SELECT schema FROM main.${C(T)}`), P = yield* g.try({
+			try: () => {
+				if (N.length !== 1) throw TypeError("Expected one retained schema");
+				let e = JSON.parse(N[0].schema);
+				if (!Array.isArray(e) || e.length !== 4 || e.some((e) => typeof e != "object" || !e || typeof e.type != "string" || typeof e.name != "string" || typeof e.sql != "string")) throw TypeError("Invalid retained witness schema");
+				return { objects: e };
+			},
+			catch: (t) => e("Retained witness protection metadata is invalid", t)
+		});
+		return yield* g.scoped(g.gen(function* () {
+			yield* i(r, E, P), yield* a(r, E), yield* h(r, S.source, E, S.reviewedSchema), yield* c(r, E, j.contents), yield* A(E), yield* o(r, E, j.rowIdentity);
+		})), {
+			copy: E,
+			marker: T,
+			manifest: M,
+			contents: j.contents,
+			rowIdentity: j.rowIdentity,
+			witnessSchema: P,
+			reviewStore: k
+		};
+	})) : yield* y("Retained sources require a SQLite-family client");
+}).pipe(g.provideService(y.SqlClient, v)), C = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", w = (e) => "'" + e.replaceAll("'", "''") + "'";
+//#endregion
+export { S as prepareSqliteRetainedSource, b as sqliteRetainedReviewNames, x as sqliteRetainedSourceNames };

package/dist/migrations/sqliteRowIdentity.js

@@ -0,0 +1,63 @@
+import { sqlError as e } from "../sqlError.js";
+import { sqliteDecimalKeyValueSql as t } from "./sqliteDecimalSource.js";
+import { Effect as n } from "effect";
+import { createHash as r } from "node:crypto";
+//#region src/migrations/sqliteRowIdentity.ts
+var i = (e) => {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return (t.alias === null || typeof t.alias == "string") && Array.isArray(t.columns) && t.columns.every((e) => typeof e == "string") && typeof t.rowCount == "number" && Number.isSafeInteger(t.rowCount) && t.rowCount >= 0 && typeof t.digest == "string" && /^[a-f0-9]{64}$/.test(t.digest) && (t.sequence === null || typeof t.sequence == "string" && /^\d+$/.test(t.sequence)) && typeof t.autoincrement == "boolean" && (t.sequenceBackend === "sqlite" || t.sequenceBackend === "turso");
+}, a = (e) => [
+	"_rowid_",
+	"rowid",
+	"oid"
+].find((t) => !e.some((e) => e.toLowerCase() === t)), o = (t, r) => n.gen(function* () {
+	let i = yield* t.executeUnprepared(`PRAGMA main.table_xinfo(${h(r)})`, [], void 0), o = (yield* t.executeUnprepared("PRAGMA main.table_list", [], void 0)).find((e) => e.name === r);
+	if (!o || o.wr !== 0 && o.wr !== 1) return yield* n.fail(e("Cannot verify SQLite row identity metadata"));
+	let s = i.map((e) => e.name), c = o.wr === 1 ? null : a(s);
+	if (c === void 0) return yield* n.fail(e("All SQLite rowid aliases are shadowed; cannot preserve implicit row identity"));
+	let { rowCount: u, digest: d } = yield* l(t, r, {
+		alias: c,
+		columns: s
+	}), f = yield* t.executeUnprepared("SELECT 1 FROM main.sqlite_master WHERE name='sqlite_sequence' AND type='table'", [], void 0), p = yield* t.executeUnprepared("SELECT 1 FROM main.sqlite_master WHERE name=? AND type='table'", [m(r)], void 0), g = ((yield* t.executeUnprepared("SELECT sql FROM main.sqlite_master WHERE name=? AND type='table'", [r], void 0))[0]?.sql ?? "").replace(/'(?:''|[^'])*'|"(?:""|[^"])*"|`(?:``|[^`])*`|\[[^\]]*\]|--[^\n]*|\/\*[\s\S]*?\*\//g, " "), _ = /\bAUTOINCREMENT\b/i.test(g), v = f.length === 0 ? [] : yield* t.executeUnprepared("SELECT CAST(seq AS TEXT) AS value FROM main.sqlite_sequence WHERE name=?", [r], void 0);
+	if (v.length > 1 || v.some((e) => !/^\d+$/.test(e.value))) return yield* n.fail(e("Invalid SQLite sequence watermark"));
+	let y = p.length === 0 ? [] : yield* t.executeUnprepared(`SELECT CAST(MAX(value) AS TEXT) AS value FROM main.${h(m(r))} WHERE is_called=1`, [], void 0);
+	return {
+		alias: c,
+		columns: s,
+		rowCount: u,
+		digest: d,
+		sequence: p.length > 0 ? y[0]?.value ?? null : v[0]?.value ?? null,
+		autoincrement: _,
+		sequenceBackend: p.length > 0 ? "turso" : "sqlite"
+	};
+}), s = (e, t, r) => c(e, t, r).pipe(n.asVoid), c = (t, r, i) => n.gen(function* () {
+	let a = yield* l(t, r, i);
+	return a.rowCount !== i.rowCount || a.digest !== i.digest ? yield* n.fail(e("Retained physical row identity changed")) : a;
+}), l = (e, t, i) => n.gen(function* () {
+	let n = r("sha256").update("["), a = 0, o;
+	if (i.alias !== null) {
+		let r = h(i.alias);
+		for (;;) {
+			let s = yield* e.executeUnprepared(`SELECT CAST(${r} AS TEXT) AS id, ${f(i.columns)} AS signature FROM main.${h(t)}
+WHERE ${o === void 0 ? "1" : `${r} > CAST(? AS INTEGER)`} ORDER BY ${r} LIMIT 256`, o === void 0 ? [] : [o], void 0);
+			for (let e of s) a > 0 && n.update(","), n.update(JSON.stringify([e.id, e.signature])), a++;
+			if (s.length < 256) break;
+			o = s[s.length - 1].id;
+		}
+	}
+	return {
+		rowCount: a,
+		digest: n.update("]").digest("hex")
+	};
+}), u = (e, t) => {
+	let n = [];
+	return t.autoincrement && (t.sequenceBackend === "turso" ? n.push(`(SELECT CAST(MAX(value) AS TEXT) FROM main.${h(m(e))} WHERE is_called=1) IS ${t.sequence === null ? "NULL" : g(t.sequence)}`) : t.sequence === null ? n.push(`NOT EXISTS (SELECT 1 FROM main.sqlite_sequence WHERE name=${g(e)})`) : n.push(`(SELECT COUNT(*) FROM main.sqlite_sequence WHERE name=${g(e)}) = 1 AND (SELECT CAST(seq AS TEXT) FROM main.sqlite_sequence WHERE name=${g(e)}) = ${g(t.sequence)}`)), n.length === 0 ? "1" : n.map((e) => `(${e})`).join(" AND ");
+}, d = (e, t) => {
+	let n = t.sequence;
+	if (n === null) return [];
+	if (!/^\d+$/.test(n)) throw TypeError("Invalid SQLite sequence watermark");
+	return t.sequenceBackend === "turso" ? [`SELECT setval(${g(p(e))},${n})`] : [`UPDATE main.sqlite_sequence SET seq=${n} WHERE name=${g(e)}`, `INSERT INTO main.sqlite_sequence(name,seq) SELECT ${g(e)},${n} WHERE NOT EXISTS (SELECT 1 FROM main.sqlite_sequence WHERE name=${g(e)})`];
+}, f = (e) => `CAST(json_array(${e.map((e) => `json_array(typeof(${h(e)}), ${t(h(e))})`).join(", ")}) AS TEXT)`, p = (e) => "__turso_internal_autoincrement_" + e, m = (e) => "__turso_internal_seq_" + p(e), h = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", g = (e) => "'" + e.replaceAll("'", "''") + "'";
+//#endregion
+export { s as assertSqliteRowIdentity, i as isSqliteRowIdentity, o as readSqliteRowIdentity, d as restoreSqliteSequenceSql, a as sqliteRowidAlias, u as sqliteSequenceMatchesSql };

package/dist/migrations/sqliteSchemaEpoch.js

@@ -0,0 +1,12 @@
+import { sqlError as e } from "../sqlError.js";
+import { Effect as t } from "effect";
+//#region src/migrations/sqliteSchemaEpoch.ts
+var n = (n) => t.gen(function* () {
+	let r = yield* n.executeUnprepared("PRAGMA main.schema_version", [], void 0), i = r[0]?.schema_version;
+	return r.length !== 1 || typeof i != "number" || !Number.isInteger(i) || i < -2147483648 || i > 2147483647 ? yield* t.fail(e("Cannot verify SQLite schema epoch")) : i;
+}), r = (e, t) => {
+	if (!Number.isInteger(e) || e < -2147483648 || e > 2147483647 || !Number.isSafeInteger(t) || t < 0 || t > 2147483647) throw TypeError("Invalid SQLite schema epoch guard");
+	return `(SELECT schema_version FROM pragma_schema_version) = ${e + t | 0}`;
+};
+//#endregion
+export { n as readSqliteSchemaEpoch, r as sqliteSchemaEpochMatchesSql };

package/dist/migrations/sqliteSnapshotGuard.js

@@ -0,0 +1,10 @@
+import { sqlError as e } from "../sqlError.js";
+import { assertSqliteRowIdentity as t } from "./sqliteRowIdentity.js";
+import { assertSqliteTableContents as n } from "./sqliteTableContents.js";
+import { Effect as r } from "effect";
+//#region src/migrations/sqliteSnapshotGuard.ts
+var i = (e, i, o, s) => r.gen(function* () {
+	yield* a(o, s), yield* n(e, i, o), yield* t(e, i, s);
+}), a = (t, n) => JSON.stringify(t.columns) === JSON.stringify(n.columns) ? r.void : r.fail(e("Retained content and physical identity columns differ"));
+//#endregion
+export { i as assertSqliteSnapshot };

package/dist/migrations/sqliteTableContents.js

@@ -0,0 +1,34 @@
+import { sqlError as e } from "../sqlError.js";
+import { readSqliteTableSchema as t } from "./sqliteTableSchema.js";
+import { sqliteDecimalKeyValueSql as n } from "./sqliteDecimalSource.js";
+import { Effect as r } from "effect";
+import { createHash as i } from "node:crypto";
+//#region src/migrations/sqliteTableContents.ts
+var a = 1024, o = (o, s) => r.gen(function* () {
+	yield* t(o, s);
+	let c = (yield* o.executeUnprepared(`PRAGMA main.table_xinfo(${l(s)})`, [], void 0)).map((e) => e.name);
+	if (c.length === 0) return yield* r.fail(e("Retained content witness requires declared columns"));
+	let u = `CAST(json_array(${c.map((e) => `json_array(typeof(${l(e)}), ${n(l(e))})`).join(", ")}) AS TEXT)`, d = i("sha256").update(`{"columns":${JSON.stringify(c)},"values":[`), f, p = !0;
+	for (;;) {
+		let t = yield* o.executeUnprepared(`SELECT ${u} AS signature, CAST(COUNT(*) AS TEXT) AS copies FROM main.${l(s)}
+WHERE ${f === void 0 ? "1" : `${u} COLLATE BINARY > ?`}
+GROUP BY ${u} COLLATE BINARY ORDER BY ${u} COLLATE BINARY LIMIT ${a}`, f === void 0 ? [] : [f], void 0);
+		for (let n of t) {
+			let t = Number(n.copies);
+			if (!Number.isSafeInteger(t) || t < 1) return yield* r.fail(e("Retained content witness has an invalid duplicate count"));
+			let i = JSON.stringify(n.signature);
+			for (let e = 0; e < t; e++) p || d.update(","), d.update(i), p = !1;
+		}
+		if (t.length < a) break;
+		f = t[t.length - 1].signature;
+	}
+	return { contents: {
+		columns: c,
+		digest: d.update("]}").digest("hex")
+	} };
+}), s = (e, t) => o(e, t).pipe(r.map((e) => e.contents)), c = (t, n, i) => r.gen(function* () {
+	let a = yield* s(t, n);
+	if (a.digest !== i.digest || JSON.stringify(a.columns) !== JSON.stringify(i.columns)) return yield* r.fail(e("Retained source contents changed; refuse publication or rollback"));
+}), l = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"";
+//#endregion
+export { c as assertSqliteTableContents, s as readSqliteTableContents };

package/dist/migrations/sqliteTableCopy.js

@@ -0,0 +1,25 @@
+import { sqlError as e } from "../sqlError.js";
+import { assertSqliteTableSchema as t } from "./sqliteTableSchema.js";
+import { Effect as n } from "effect";
+//#region src/migrations/sqliteTableCopy.ts
+var r = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", i = (e, t, n) => {
+	if (n.length === 0) throw TypeError("Table copy comparison requires columns");
+	let i = n.flatMap((e) => [`typeof(${r(e)})`, `${r(e)} COLLATE BINARY`]), a = (e) => `SELECT ${i.join(", ")}, COUNT(*) FROM main.${r(e)} GROUP BY ${i.join(", ")}`;
+	return `WITH source_rows AS (${a(e)}), copy_rows AS (${a(t)}),
+missing_from_copy AS (SELECT * FROM source_rows EXCEPT SELECT * FROM copy_rows),
+missing_from_source AS (SELECT * FROM copy_rows EXCEPT SELECT * FROM source_rows)
+SELECT 1 AS changed WHERE EXISTS (SELECT * FROM missing_from_copy)
+OR EXISTS (SELECT * FROM missing_from_source)`;
+}, a = (a, o, s, c) => n.gen(function* () {
+	let l = (t) => n.fail(e(`Table copy verification failed: ${t}; retain the source and rebuild the conversion stage`));
+	if (o.toLowerCase() === s.toLowerCase()) return yield* l("source and copy must be distinct tables");
+	c !== void 0 && (yield* t(a, o, c));
+	let u = (e) => n.gen(function* () {
+		let t = yield* a.executeUnprepared("SELECT sql FROM main.sqlite_master WHERE type = ? AND name = ? COLLATE NOCASE", ["table", e], void 0);
+		return t.length !== 1 || !/^CREATE\s+TABLE\b/i.test(t[0]?.sql ?? "") ? yield* l("both inputs must be existing ordinary tables in main") : (yield* a.executeUnprepared(`PRAGMA main.table_xinfo(${r(e)})`, [], void 0)).map((e) => e.name);
+	}), d = yield* u(o), f = yield* u(s);
+	if (d.length === 0 || d.length !== f.length || d.some((e, t) => e !== f[t])) return yield* l("source and copy columns differ");
+	if ((yield* a.executeUnprepared(i(o, s, d), [], void 0)).length > 0) return yield* l("source rows changed or the retained copy is incomplete");
+});
+//#endregion
+export { a as assertSqliteTableCopy, i as sqliteTableCopyDifferenceSql };

package/dist/migrations/sqliteTableSchema.js

@@ -0,0 +1,19 @@
+import { sqlError as e } from "../sqlError.js";
+import { Effect as t } from "effect";
+//#region src/migrations/sqliteTableSchema.ts
+var n = (e, t) => {
+	let n = `main.sqlite_master WHERE tbl_name = ${r(e)} COLLATE NOCASE AND type IN ('table', 'index', 'trigger')`;
+	return [`(SELECT COUNT(*) FROM ${n}) = ${t.objects.length}`, ...t.objects.map((e) => `EXISTS (SELECT 1 FROM ${n} AND type = ${r(e.type)} AND name = ${r(e.name)} AND sql IS ${e.sql === null ? "NULL" : r(e.sql)})`)].join(" AND ");
+}, r = (e) => "'" + e.replaceAll("'", "''") + "'", i = (n, r) => t.gen(function* () {
+	let i = yield* n.executeUnprepared("SELECT type, name, sql FROM main.sqlite_master\nWHERE tbl_name = ? COLLATE NOCASE AND type IN ('table', 'index', 'trigger')\nORDER BY type COLLATE BINARY, name COLLATE BINARY", [r], void 0), a = i.filter((e) => e.type === "table");
+	return a.length !== 1 || !/^CREATE\s+TABLE\b/i.test(a[0]?.sql ?? "") ? yield* t.fail(e("Schema verification requires an existing ordinary table in main")) : { objects: i.map(({ type: e, name: t, sql: n }) => ({
+		type: e,
+		name: t,
+		sql: n
+	})) };
+}), a = (n, r, a) => t.gen(function* () {
+	let o = yield* i(n, r);
+	if (JSON.stringify(o) !== JSON.stringify(a)) return yield* t.fail(e("Source table schema changed; retain the source and review the conversion stage again"));
+});
+//#endregion
+export { a as assertSqliteTableSchema, i as readSqliteTableSchema, n as sqliteTableSchemaMatchesSql };

package/dist/migrations/sqliteWitnessProtection.js

@@ -0,0 +1,8 @@
+//#region src/migrations/sqliteWitnessProtection.ts
+var e = (e, t) => n.map((n) => `CREATE TRIGGER ${r(`${t}_protect_${n.toLowerCase()}`)} BEFORE ${n} ON ${r(e)} BEGIN SELECT RAISE(ABORT, 'Retained conversion witness is immutable'); END`), t = (e) => n.map((t) => `DROP TRIGGER ${r(`${e}_protect_${t.toLowerCase()}`)}`), n = [
+	"INSERT",
+	"UPDATE",
+	"DELETE"
+], r = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"";
+//#endregion
+export { t as dropSqliteWitnessProtectionStatements, e as sqliteWitnessProtectionStatements };