@voltro/database 0.85.0 → 0.86.0

package/dist/migrations/sqliteConstraintIdentity.js

@@ -0,0 +1,97 @@
+//#region src/migrations/sqliteConstraintIdentity.ts
+var e = (e) => e.replace(/[A-Z]/g, (e) => e.toLowerCase()), t = (t) => JSON.stringify(t.map(e)), n = (e) => {
+	let t = [];
+	for (let n = 0; n < e.length;) {
+		let r = e[n];
+		if (/\s/.test(r)) {
+			n++;
+			continue;
+		}
+		if (e.startsWith("--", n)) {
+			let t = e.indexOf("\n", n + 2);
+			n = t < 0 ? e.length : t + 1;
+			continue;
+		}
+		if (e.startsWith("/*", n)) {
+			let t = e.indexOf("*/", n + 2);
+			if (t < 0) return [];
+			n = t + 2;
+			continue;
+		}
+		if (r === "\"" || r === "`" || r === "[" || r === "'") {
+			let i = r === "[" ? "]" : r, a = "", o = !1;
+			for (n++; n < e.length;) {
+				if (e[n] === i) {
+					if (r !== "[" && e[n + 1] === i) {
+						r !== "'" && (a += i), n += 2;
+						continue;
+					}
+					n++, o = !0;
+					break;
+				}
+				r !== "'" && (a += e[n]), n++;
+			}
+			if (!o) return [];
+			t.push({
+				text: a,
+				kind: r === "'" ? "literal" : "identifier"
+			});
+			continue;
+		}
+		if ("(),;".includes(r)) {
+			t.push({
+				text: r,
+				kind: "punctuation"
+			}), n++;
+			continue;
+		}
+		let i = n++;
+		for (; n < e.length && !/[\s()\[\],;"'`]/.test(e[n]) && !e.startsWith("--", n) && !e.startsWith("/*", n);) n++;
+		t.push({
+			text: e.slice(i, n),
+			kind: "word"
+		});
+	}
+	return t;
+}, r = (e) => {
+	let r = n(e), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set(), o = (e, t) => e?.kind === "word" && e.text.toUpperCase() === t, s = (e) => e !== void 0 && (e.kind === "identifier" || e.kind === "word" && /^[\p{L}_][\p{L}\p{N}_$]*$/u.test(e.text)), c = (e) => {
+		let n = o(e[0], "CONSTRAINT") && s(e[1]), r = n ? 2 : 0;
+		if (!o(e[r], "UNIQUE") || e[r + 1]?.text !== "(") return;
+		let c = [], l = r + 2, u = !1;
+		for (; s(e[l]);) {
+			if (c.push(e[l++].text), o(e[l], "COLLATE")) {
+				if (u = !0, !s(e[l + 1])) return;
+				l += 2;
+			}
+			if ((o(e[l], "ASC") || o(e[l], "DESC")) && (u = !0, l++), e[l]?.text === ")") break;
+			if (e[l++]?.text !== ",") return;
+		}
+		if (!c.length || e[l]?.text !== ")") return;
+		let d = e.slice(l + 1);
+		if (d.length && !(d.length === 3 && o(d[0], "ON") && o(d[1], "CONFLICT") && [
+			"ROLLBACK",
+			"ABORT",
+			"FAIL",
+			"IGNORE",
+			"REPLACE"
+		].some((e) => o(d[2], e)))) return;
+		let f = t(c);
+		a.has(f) || u ? i.delete(f) : n && i.set(f, e[1].text), a.add(f);
+	}, l = 0, u = -1;
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e];
+		if (t.kind === "punctuation") {
+			if (t.text === "(") l++ === 0 && (u = e + 1);
+			else if (t.text === ")") {
+				if (--l === 0) {
+					c(r.slice(u, e));
+					break;
+				}
+				if (l < 0) return /* @__PURE__ */ new Map();
+			} else t.text === "," && l === 1 && (c(r.slice(u, e)), u = e + 1);
+		}
+	}
+	return l === 0 ? i : /* @__PURE__ */ new Map();
+};
+//#endregion
+export { r as sqliteNamedUniqueConstraints, t as sqliteUniqueColumnsKey };

package/dist/migrations/sqliteDecimalBoot.js

@@ -0,0 +1,22 @@
+import { parseSqliteDecimalStorageType as e, sqliteDecimalStorageShape as t } from "../sqliteDecimalStorage.js";
+import { sqlError as n } from "../sqlError.js";
+import { dialectOf as r } from "./resumeLedger.js";
+import { Effect as i } from "effect";
+//#region src/migrations/sqliteDecimalBoot.ts
+var a = (a, o) => i.gen(function* () {
+	if (o.length === 0) return;
+	let s = r(a);
+	if (s !== "sqlite" && s !== "turso") return;
+	let c = yield* a.unsafe("SELECT name FROM sqlite_master WHERE type = 'table' AND sql LIKE '%VOLTRO_DECIMAL_V1_%'"), l = new Set(c.map((e) => e.name));
+	for (let r of o) {
+		let o = Object.values(r.fields).some((e) => t(e) !== void 0);
+		if (!l.has(r.tableName) && !o) continue;
+		let s = "\"" + r.tableName.replaceAll("\"", "\"\"") + "\"", c = yield* a.unsafe(`PRAGMA table_info(${s})`), u = new Map(c.map((e) => [e.name, e]));
+		for (let [a, o] of Object.entries(r.fields)) {
+			let s = t(o), c = e(u.get(a)?.type ?? "");
+			if ((s !== void 0 || c !== void 0) && (s?.precision !== c?.precision || s?.scale !== c?.scale)) return yield* i.fail(n(`Decimal storage representation does not match the application schema at ${r.tableName}.${a}; complete the verified storage migration before starting this application`));
+		}
+	}
+});
+//#endregion
+export { a as verifySqliteDecimalStorage };

package/dist/migrations/sqliteDecimalPublication.js

@@ -0,0 +1,257 @@
+import { sqlError as e } from "../sqlError.js";
+import { runSqliteMigrationBatch as t } from "./sqliteMigrationBatch.js";
+import { emitCreateTableSqlite as n } from "./applier.js";
+import { assertSqliteTableSchema as r, sqliteTableSchemaMatchesSql as i } from "./sqliteTableSchema.js";
+import { isSqliteRowIdentity as a, readSqliteRowIdentity as o, restoreSqliteSequenceSql as s, sqliteSequenceMatchesSql as c } from "./sqliteRowIdentity.js";
+import { readSqliteTableContents as l } from "./sqliteTableContents.js";
+import { assertSqliteSnapshot as u } from "./sqliteSnapshotGuard.js";
+import { readSqliteSchemaEpoch as d, sqliteSchemaEpochMatchesSql as f } from "./sqliteSchemaEpoch.js";
+import { sqliteDecimalReviewInputWitness as p } from "./sqliteDecimalReviewWitness.js";
+import { dropSqliteWitnessProtectionStatements as m, sqliteWitnessProtectionStatements as h } from "./sqliteWitnessProtection.js";
+import { readSqliteDecimalReviewStore as g } from "./sqliteDecimalReviewStore.js";
+import { sqliteTableCopyDifferenceSql as _ } from "./sqliteTableCopy.js";
+import { sqliteRetainedReviewNames as v, sqliteRetainedSourceNames as y } from "./sqliteRetainedSource.js";
+import { prepareSqliteDecimalStage as b } from "./sqliteDecimalStage.js";
+import { Effect as x } from "effect";
+//#region src/migrations/sqliteDecimalPublication.ts
+var S = (s, p, g, C = []) => x.gen(function* () {
+	let j = (t) => x.fail(e(t));
+	if (!p.decimalReview) return yield* j("Decimal publication requires reviewed conversion decisions");
+	let M = y(p), N = `${M.marker}_stage_owner`, P = `${M.marker}_publication`, F = `${M.marker}_published_rows`, I = `CREATE TABLE ${T(P)} (manifest TEXT NOT NULL, schema TEXT NOT NULL, artifacts TEXT NOT NULL)`, L = yield* k(p, g, C);
+	if (new Set(C.map((e) => e.name)).size !== C.length || C.some((e) => !/^CREATE\s+TRIGGER\s/i.test(e.sql)) || p.reviewedSchema.objects.some((e) => e.type === "trigger" && !C.some((t) => t.name === e.name))) return yield* j("Decimal publication requires explicit reviewed definitions for every source trigger");
+	let R = yield* s.unsafe("SELECT sql FROM main.sqlite_master WHERE name = ? COLLATE NOCASE", [P]);
+	if (R.length === 0) {
+		let e = yield* b(s, p, g), r = yield* x.scoped(x.gen(function* () {
+			return yield* l(yield* s.reserve, e.stage);
+		})), a = yield* x.scoped(x.gen(function* () {
+			return yield* o(yield* s.reserve, e.stage);
+		})), u = {
+			phase: "published",
+			sourceInsertColumns: (yield* s.unsafe(`PRAGMA main.table_xinfo(${T(p.source)})`)).filter((e) => e.hidden === 0).map((e) => e.name),
+			identity: L,
+			sourceManifest: e.sourceManifest,
+			stageManifest: e.manifest,
+			sourceContents: e.sourceContents,
+			sourceRowIdentity: e.sourceRowIdentity,
+			imageRowIdentity: a,
+			imageContents: r
+		}, d = `${M.marker}_publish_guard`, y = [
+			i(p.source, p.reviewedSchema),
+			i(e.stage, e.schema),
+			`NOT EXISTS (${_(p.source, M.copy, [...e.sourceRowIdentity.alias === null ? [] : [e.sourceRowIdentity.alias], ...e.sourceContents.columns])})`,
+			f(e.validationEpoch, 2),
+			c(p.source, e.sourceRowIdentity),
+			c(e.stage, a),
+			D(M.marker, e.sourceManifest),
+			D(N, e.manifest)
+		].map((e) => `(${e})`).join(" AND "), S = n({
+			kind: "create-table",
+			table: p.source,
+			columns: g.columns,
+			indexes: g.indexes,
+			...g.primaryKey ? { primaryKey: g.primaryKey } : {}
+		}).slice(1).map((e) => e.replace(/ IF NOT EXISTS /, " ")), w = C.map((e) => e.sql.replace(/^(CREATE\s+TRIGGER)\s+IF\s+NOT\s+EXISTS\s+/i, "$1 ")), O = [`(SELECT COUNT(*) FROM main.sqlite_master WHERE type='trigger' AND tbl_name=${E(p.source)}) = ${C.length}`, ...C.map((e) => `EXISTS (SELECT 1 FROM main.sqlite_master WHERE type='trigger' AND name=${E(e.name)} AND tbl_name=${E(p.source)})`)].join(" AND ");
+		yield* t(s, [
+			I,
+			`CREATE TABLE ${T(d)} (valid INTEGER CHECK(valid = 1))`,
+			`INSERT INTO ${T(d)} SELECT CASE WHEN ${y} THEN 1 ELSE 0 END`,
+			...m(N),
+			`DROP TABLE ${T(p.source)}`,
+			...e.indexes.map((e) => `DROP INDEX ${T(e)}`),
+			`ALTER TABLE ${T(e.stage)} RENAME TO ${T(p.source)}`,
+			...S,
+			...w,
+			`INSERT INTO ${T(d)} SELECT CASE WHEN ${O} THEN 1 ELSE 0 END`,
+			`CREATE TABLE ${T(F)} AS SELECT * FROM main.${T(p.source)} WHERE 0`,
+			`INSERT INTO ${T(F)} (${[...a.alias === null ? [] : [a.alias], ...r.columns].map(T).join(", ")}) SELECT ${[...a.alias === null ? [] : [a.alias], ...r.columns].map(T).join(", ")} FROM main.${T(p.source)}`,
+			...h(F, P),
+			`INSERT INTO ${T(P)} SELECT ${E(JSON.stringify(u))}, (SELECT json_group_array(json_object('type',type,'name',name,'sql',sql)) FROM (SELECT type,name,sql FROM main.sqlite_master WHERE tbl_name=${E(p.source)} AND type IN ('table','index','trigger') ORDER BY type COLLATE BINARY,name COLLATE BINARY)), ${A([
+				M.marker,
+				M.copy,
+				...Object.values(v(p)),
+				N,
+				F
+			])}`,
+			`DROP TABLE ${T(d)}`
+		]);
+	} else if (R.length !== 1 || R[0]?.sql !== I) return yield* j("Decimal publication marker is not owned by this conversion");
+	let z = yield* s.unsafe(`SELECT manifest,schema,artifacts FROM main.${T(P)}`);
+	if (z.length !== 1) return yield* j("Decimal publication receipt is incomplete");
+	let B = yield* x.try({
+		try: () => {
+			let e = JSON.parse(z[0].manifest), t = { objects: JSON.parse(z[0].schema) };
+			if (!a(e.sourceRowIdentity) || !a(e.imageRowIdentity) || !["published", "rolled-back"].includes(e.phase) || !Array.isArray(e.sourceInsertColumns) || e.identity !== L || typeof e.sourceManifest != "string" || typeof e.stageManifest != "string" || typeof e.sourceContents?.digest != "string" || !Array.isArray(e.sourceContents.columns) || typeof e.imageContents?.digest != "string" || !Array.isArray(e.imageContents.columns)) throw TypeError("Mismatched publication identity");
+			return {
+				receipt: e,
+				schema: t
+			};
+		},
+		catch: (t) => e("Decimal publication receipt does not match the requested conversion", t)
+	});
+	if (B.receipt.phase === "rolled-back") {
+		yield* w(s, p, g, C);
+		let e = `${M.marker}_restart_guard`, n = JSON.stringify({
+			...B.receipt,
+			cleaned: !0
+		}), r = [
+			i(p.source, B.schema),
+			`EXISTS (SELECT 1 FROM main.sqlite_master WHERE name = ${E(P)} AND type = 'table' AND sql = ${E(I)})`,
+			`(SELECT COUNT(*) FROM ${T(P)}) = 1`,
+			`EXISTS (SELECT 1 FROM ${T(P)} WHERE manifest = ${E(n)} AND schema = ${E(z[0].schema)} AND artifacts = ${E(z[0].artifacts)})`
+		].map((e) => `(${e})`).join(" AND ");
+		return yield* t(s, [
+			`CREATE TABLE ${T(e)} (valid INTEGER CHECK(valid = 1))`,
+			`INSERT INTO ${T(e)} SELECT CASE WHEN ${r} THEN 1 ELSE 0 END`,
+			`DROP TABLE ${T(P)}`,
+			`DROP TABLE ${T(e)}`
+		]), yield* S(s, p, g, C);
+	}
+	return B.receipt.cleaned === !0 ? (yield* x.scoped(x.gen(function* () {
+		yield* r(yield* s.reserve, p.source, B.schema);
+	})), {
+		marker: P,
+		image: F,
+		sourceCopy: M.copy
+	}) : (yield* s.unsafe(`SELECT 1 WHERE NOT (${D(M.marker, B.receipt.sourceManifest)} AND ${D(N, B.receipt.stageManifest)} AND CAST(${A([
+		M.marker,
+		M.copy,
+		...Object.values(v(p)),
+		N,
+		F
+	])} AS TEXT) = ${E(z[0].artifacts)})`)).length > 0 ? yield* j("Retained decimal artifact ownership changed after publication") : (yield* x.scoped(x.gen(function* () {
+		let e = yield* s.reserve, t = yield* d(e);
+		if (yield* O(e, p), yield* r(e, p.source, B.schema), yield* u(e, M.copy, B.receipt.sourceContents, B.receipt.sourceRowIdentity), yield* u(e, F, B.receipt.imageContents, B.receipt.imageRowIdentity), (yield* d(e)) !== t) return yield* j("Decimal publication artifacts changed during validation");
+	})), {
+		marker: P,
+		image: F,
+		sourceCopy: M.copy
+	});
+}), C = (n, o, l, p = []) => x.gen(function* () {
+	let m = (t) => x.fail(e(t)), h = y(o), g = `${h.marker}_publication`, b = `${h.marker}_published_rows`, C = `${h.marker}_stage_owner`, w = `CREATE TABLE ${T(g)} (manifest TEXT NOT NULL, schema TEXT NOT NULL, artifacts TEXT NOT NULL)`, j = yield* n.unsafe("SELECT sql FROM main.sqlite_master WHERE name = ? COLLATE NOCASE", [g]);
+	if (j.length !== 1 || j[0]?.sql !== w) return yield* m("No owned decimal publication to roll back");
+	let M = yield* n.unsafe(`SELECT manifest,schema,artifacts FROM main.${T(g)}`);
+	if (M.length !== 1) return yield* m("Decimal publication receipt is incomplete");
+	let N = yield* k(o, l, p), P = yield* x.try({
+		try: () => {
+			let e = JSON.parse(M[0].manifest), t = { objects: JSON.parse(M[0].schema) };
+			if (!a(e.sourceRowIdentity) || !a(e.imageRowIdentity) || e.identity !== N || !["published", "rolled-back"].includes(e.phase) || !Array.isArray(e.sourceInsertColumns) || e.sourceInsertColumns.length === 0 || e.sourceInsertColumns.some((e) => typeof e != "string")) throw TypeError("Invalid rollback receipt");
+			return {
+				receipt: e,
+				schema: t
+			};
+		},
+		catch: (t) => e("Decimal rollback identity does not match publication", t)
+	});
+	if (P.receipt.phase === "rolled-back") {
+		yield* x.scoped(x.gen(function* () {
+			let e = yield* n.reserve, t = yield* d(e);
+			if (P.receipt.cleaned !== !0 && (yield* O(e, o)), yield* r(e, o.source, P.schema), (yield* d(e)) !== t) return yield* m("Decimal rollback artifacts changed during validation");
+		}));
+		return;
+	}
+	if (P.receipt.cleaned === !0) return yield* m("Decimal rollback is no longer available after artifact cleanup");
+	yield* S(n, o, l, p);
+	let F = yield* x.scoped(x.gen(function* () {
+		let e = yield* n.reserve, t = yield* d(e);
+		return yield* O(e, o), yield* u(e, h.copy, P.receipt.sourceContents, P.receipt.sourceRowIdentity), yield* u(e, b, P.receipt.imageContents, P.receipt.imageRowIdentity), t;
+	})), I = o.reviewedSchema.objects.find((e) => e.type === "table");
+	if (!I?.sql) return yield* m("Original table definition is missing");
+	let L = [...P.receipt.sourceRowIdentity.alias === null ? [] : [P.receipt.sourceRowIdentity.alias], ...P.receipt.sourceInsertColumns].map(T).join(", "), R = `${h.marker}_rollback_guard`, z = [
+		i(o.source, P.schema),
+		`CAST(${A([
+			h.marker,
+			h.copy,
+			...Object.values(v(o)),
+			C,
+			b
+		])} AS TEXT) = ${E(M[0].artifacts)}`,
+		f(F, 1),
+		`NOT EXISTS (${_(o.source, b, [...P.receipt.imageRowIdentity.alias === null ? [] : [P.receipt.imageRowIdentity.alias], ...P.receipt.imageContents.columns])})`,
+		c(o.source, P.receipt.imageRowIdentity),
+		D(h.marker, P.receipt.sourceManifest),
+		D(C, P.receipt.stageManifest),
+		`(SELECT COUNT(*) FROM ${T(g)}) = 1`,
+		`EXISTS (SELECT 1 FROM ${T(g)} WHERE manifest = ${E(M[0].manifest)} AND schema = ${E(M[0].schema)})`
+	].map((e) => `(${e})`).join(" AND ");
+	yield* t(n, [
+		`CREATE TABLE ${T(R)} (valid INTEGER CHECK(valid = 1))`,
+		`INSERT INTO ${T(R)} SELECT CASE WHEN ${z} THEN 1 ELSE 0 END`,
+		`DROP TABLE ${T(o.source)}`,
+		I.sql,
+		`INSERT INTO ${T(o.source)} (${L}) SELECT ${L} FROM ${T(h.copy)}`,
+		...s(o.source, P.receipt.sourceRowIdentity),
+		...o.reviewedSchema.objects.filter((e) => e.type !== "table" && e.sql !== null).map((e) => e.sql),
+		`INSERT INTO ${T(R)} SELECT CASE WHEN NOT EXISTS (${_(o.source, h.copy, P.receipt.sourceContents.columns)}) THEN 1 ELSE 0 END`,
+		`UPDATE ${T(g)} SET manifest = ${E(JSON.stringify({
+			...P.receipt,
+			phase: "rolled-back"
+		}))}, schema = (SELECT json_group_array(json_object('type',type,'name',name,'sql',sql)) FROM (SELECT type,name,sql FROM main.sqlite_master WHERE tbl_name=${E(o.source)} AND type IN ('table','index','trigger') ORDER BY type COLLATE BINARY,name COLLATE BINARY))`,
+		`DROP TABLE ${T(R)}`
+	]);
+}), w = (n, r, o, s = []) => x.gen(function* () {
+	let c = (t) => x.fail(e(t)), l = y(r), p = `${l.marker}_publication`, m = `${l.marker}_published_rows`, h = `${l.marker}_stage_owner`, g = [
+		l.marker,
+		l.copy,
+		...Object.values(v(r)),
+		h,
+		m
+	], _ = `CREATE TABLE ${T(p)} (manifest TEXT NOT NULL, schema TEXT NOT NULL, artifacts TEXT NOT NULL)`, b = yield* n.unsafe("SELECT sql FROM main.sqlite_master WHERE name = ? COLLATE NOCASE", [p]);
+	if (b.length !== 1 || b[0]?.sql !== _) return yield* c("No owned decimal publication to clean up");
+	let w = yield* n.unsafe(`SELECT manifest,schema,artifacts FROM main.${T(p)}`);
+	if (w.length !== 1) return yield* c("Decimal publication receipt is incomplete");
+	let j = yield* k(r, o, s), M = yield* x.try({
+		try: () => {
+			let e = JSON.parse(w[0].manifest), t = { objects: JSON.parse(w[0].schema) };
+			if (!a(e.sourceRowIdentity) || !a(e.imageRowIdentity) || e.identity !== j || !["published", "rolled-back"].includes(e.phase)) throw TypeError("Invalid cleanup receipt");
+			return {
+				receipt: e,
+				schema: t
+			};
+		},
+		catch: (t) => e("Decimal cleanup identity does not match publication", t)
+	});
+	if (M.receipt.phase === "published" ? yield* S(n, r, o, s) : yield* C(n, r, o, s), M.receipt.cleaned === !0) return;
+	let N = yield* x.scoped(x.gen(function* () {
+		let e = yield* n.reserve, t = yield* d(e);
+		return yield* O(e, r), yield* u(e, l.copy, M.receipt.sourceContents, M.receipt.sourceRowIdentity), yield* u(e, m, M.receipt.imageContents, M.receipt.imageRowIdentity), t;
+	})), P = `${l.marker}_cleanup_guard`, F = [
+		i(r.source, M.schema),
+		f(N, 1),
+		`CAST(${A(g)} AS TEXT) = ${E(w[0].artifacts)}`,
+		D(l.marker, M.receipt.sourceManifest),
+		D(h, M.receipt.stageManifest),
+		`(SELECT COUNT(*) FROM ${T(p)}) = 1`,
+		`EXISTS (SELECT 1 FROM ${T(p)} WHERE manifest = ${E(w[0].manifest)} AND schema = ${E(w[0].schema)} AND artifacts = ${E(w[0].artifacts)})`
+	].map((e) => `(${e})`).join(" AND ");
+	yield* t(n, [
+		`CREATE TABLE ${T(P)} (valid INTEGER CHECK(valid = 1))`,
+		`INSERT INTO ${T(P)} SELECT CASE WHEN ${F} THEN 1 ELSE 0 END`,
+		...g.map((e) => `DROP TABLE ${T(e)}`),
+		`UPDATE ${T(p)} SET manifest = ${E(JSON.stringify({
+			...M.receipt,
+			cleaned: !0
+		}))}`,
+		`DROP TABLE ${T(P)}`
+	]);
+}), T = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", E = (e) => "'" + e.replaceAll("'", "''") + "'", D = (e, t) => `(SELECT COUNT(*) FROM main.${T(e)}) = 1 AND EXISTS (SELECT 1 FROM main.${T(e)} WHERE manifest=${E(t)})`, O = (t, n) => x.gen(function* () {
+	let r = yield* x.try({
+		try: () => p(n.decimalReview.cells),
+		catch: (t) => e("Invalid decimal publication review", t)
+	}), i = y(n), a = v(n);
+	yield* g(t, a.table, i.marker, r);
+}), k = (t, n, r) => x.try({
+	try: () => JSON.stringify({
+		migrationId: t.migrationId,
+		source: t.source,
+		targetIdentity: t.targetIdentity,
+		reviewedSchema: t.reviewedSchema,
+		keys: t.decimalReview.keys,
+		columns: t.decimalReview.columns,
+		review: p(t.decimalReview.cells),
+		target: n,
+		triggers: r
+	}),
+	catch: (t) => e("Invalid decimal publication review", t)
+}), A = (e) => `(SELECT json_group_array(json_object('type',type,'name',name,'sql',sql,'table',tbl_name)) FROM (SELECT type,name,sql,tbl_name FROM main.sqlite_master WHERE tbl_name IN (${e.map(E).join(", ")}) AND type IN ('table','index','trigger') ORDER BY tbl_name COLLATE BINARY,type COLLATE BINARY,name COLLATE BINARY))`;
+//#endregion
+export { w as cleanupSqliteDecimalPublication, S as publishSqliteDecimalStage, C as rollbackSqliteDecimalPublication };

package/dist/migrations/sqliteDecimalReview.js

@@ -0,0 +1,30 @@
+import { convertSqliteDecimalValue as e } from "../sqliteDecimalConversion.js";
+//#region src/migrations/sqliteDecimalReview.ts
+var t = (e) => {
+	let t = e.value;
+	return JSON.stringify({
+		kind: e.kind,
+		observed: t === null ? ["null"] : [typeof t, typeof t == "number" && Object.is(t, -0) ? "-0" : String(t)],
+		shape: e.kind === "sortable-v1" ? e.shape : null
+	});
+}, n = (t) => {
+	if (!t.rowIdentity || !t.column) throw TypeError("Decimal review requires row and column identities");
+	let n = e(t.source, t.target), r = t.source.value, i = r === null ? ["null"] : [typeof r, typeof r == "number" && Object.is(r, -0) ? "-0" : String(r)], a = JSON.stringify({
+		kind: t.source.kind,
+		observed: i,
+		shape: t.source.kind === "sortable-v1" ? t.source.shape : null,
+		resolution: t.source.kind === "numeric" ? t.source.resolution ?? null : null
+	});
+	return {
+		rowIdentity: t.rowIdentity,
+		column: t.column,
+		encoded: n,
+		sourceIdentity: a,
+		target: {
+			precision: t.target.precision,
+			scale: t.target.scale
+		}
+	};
+}, r = (e) => JSON.stringify([e.rowIdentity, e.column]);
+//#endregion
+export { n as normalizeSqliteDecimalCell, r as sqliteDecimalDecisionIdentity, t as sqliteDecimalObservationIdentity };

package/dist/migrations/sqliteDecimalReviewStore.js

@@ -0,0 +1,188 @@
+import { sqlError as e } from "../sqlError.js";
+import { runSqliteMigrationStatement as t } from "./sqliteMigrationBatch.js";
+import { assertSqliteTableSchema as n, readSqliteTableSchema as r } from "./sqliteTableSchema.js";
+import { forEachSqliteDecimalSourcePage as i } from "./sqliteDecimalSource.js";
+import { readSqliteSchemaEpoch as a } from "./sqliteSchemaEpoch.js";
+import { normalizeSqliteDecimalCell as o, sqliteDecimalDecisionIdentity as s, sqliteDecimalObservationIdentity as c } from "./sqliteDecimalReview.js";
+import { createSqliteDecimalReviewWitness as l } from "./sqliteDecimalReviewWitness.js";
+import { sqliteWitnessProtectionStatements as u } from "./sqliteWitnessProtection.js";
+import { Effect as d, Option as f } from "effect";
+import { SqlClient as p } from "effect/sql";
+//#region src/migrations/sqliteDecimalReviewStore.ts
+var m = (n, i, a) => d.gen(function* () {
+	let s = (t) => e("Invalid stored decimal review", t), l = yield* p.SqlClient, m = yield* d.serviceOption(l.transactionService);
+	if (f.isNone(m)) return yield* d.fail(e("Decimal review import requires a pinned transaction"));
+	if (!n.startsWith("_voltro_review_") || !i) return yield* d.fail(s("Missing review artifact identity"));
+	let h = m.value[0], g = `${n}_owner`;
+	yield* t(h, `CREATE TABLE main.${w(g)} (manifest TEXT NOT NULL, schema TEXT NOT NULL)`), yield* t(h, `CREATE TABLE main.${w(n)} (sort_key TEXT NOT NULL PRIMARY KEY, payload TEXT NOT NULL, observation TEXT NOT NULL)`);
+	let _ = yield* d.try({
+		try: () => a[Symbol.iterator](),
+		catch: s
+	});
+	yield* d.acquireUseRelease(d.succeed(_), (e) => d.gen(function* () {
+		for (;;) {
+			let t = yield* d.try({
+				try: () => e.next(),
+				catch: s
+			});
+			if (t.done) break;
+			let r = yield* d.try({
+				try: () => o(t.value),
+				catch: s
+			}), i = C(r);
+			yield* h.executeUnprepared(`INSERT INTO main.${w(n)} (sort_key,payload,observation) VALUES (?,?,?)`, [
+				i,
+				JSON.stringify(r),
+				c(t.value.source)
+			], void 0);
+		}
+	}), (e) => d.sync(() => {
+		e.return?.();
+	}));
+	let v = yield* S(h, n);
+	for (let e of u(n, g)) yield* t(h, e);
+	let y = yield* r(h, n), b = JSON.stringify({
+		version: 1,
+		owner: i,
+		review: v
+	});
+	yield* h.executeUnprepared(`INSERT INTO main.${w(g)} (manifest,schema) VALUES (?,?)`, [b, JSON.stringify(y)], void 0);
+	for (let e of u(g, `${g}_receipt`)) yield* t(h, e);
+	return {
+		table: n,
+		marker: g,
+		manifest: b,
+		schema: y,
+		receiptSchema: y,
+		markerSchema: yield* r(h, g),
+		witness: v
+	};
+}), h = (t, n, r) => d.gen(function* () {
+	let i = yield* p.SqlClient, a = yield* d.serviceOption(i.transactionService);
+	return f.isNone(a) ? yield* d.fail(e("Decimal review reopening requires a pinned transaction")) : yield* g(a.value[0], t, n, r);
+}), g = (t, n, i, a) => d.gen(function* () {
+	if (!n.startsWith("_voltro_review_") || !i) return yield* d.fail(e("Missing review artifact identity"));
+	let o = `${n}_owner`, s = [
+		"sqlite",
+		"turso",
+		"turso-renamed"
+	], c = s.map((e) => _(n, o, !1, e)), l = s.map((e) => _(o, `${o}_receipt`, !0, e)), u = yield* r(t, n), f = yield* r(t, o), p = c.find((e) => JSON.stringify(e) === JSON.stringify(u)), m = l.find((e) => JSON.stringify(e) === JSON.stringify(f)), h = yield* t.executeUnprepared(`SELECT schema FROM main.${w(o)}`, [], void 0), g = h.length === 1 ? c.find((e) => JSON.stringify(e) === h[0].schema) : void 0;
+	if (!p || !m || !g) return yield* d.fail(e("Stored decimal review schema is not an owned definition"));
+	let v = {
+		table: n,
+		marker: o,
+		schema: p,
+		receiptSchema: g,
+		markerSchema: m,
+		witness: a,
+		manifest: JSON.stringify({
+			version: 1,
+			owner: i,
+			review: a
+		})
+	};
+	return yield* y(t, v), v;
+}), _ = (e, t, n, r) => {
+	let i = [{
+		type: "table",
+		name: e,
+		sql: `CREATE TABLE ${w(e)} (${n ? "manifest TEXT NOT NULL, schema TEXT NOT NULL" : "sort_key TEXT NOT NULL PRIMARY KEY, payload TEXT NOT NULL, observation TEXT NOT NULL"})`
+	}];
+	n || i.push({
+		type: "index",
+		name: `sqlite_autoindex_${e}_1`,
+		sql: null
+	});
+	let a = u(e, t);
+	for (let [e, n] of [
+		"insert",
+		"update",
+		"delete"
+	].entries()) {
+		let o = a[e];
+		r !== "sqlite" && (o = o.replace("BEGIN SELECT RAISE(", "BEGIN SELECT RAISE (")), r === "turso-renamed" && (o = o.replace(" BEGIN SELECT ", " BEGIN\nSELECT ").replace("; END", ";\nEND")), i.push({
+			type: "trigger",
+			name: `${t}_protect_${n}`,
+			sql: o
+		});
+	}
+	return i.sort((e, t) => e.type < t.type ? -1 : e.type > t.type ? 1 : e.name < t.name ? -1 : +(e.name > t.name)), { objects: i };
+}, v = (t) => d.gen(function* () {
+	let n = yield* p.SqlClient, r = yield* d.serviceOption(n.transactionService);
+	if (f.isNone(r)) return yield* d.fail(e("Decimal review verification requires a pinned transaction"));
+	yield* y(r.value[0], t);
+}), y = (t, r) => d.gen(function* () {
+	let i = yield* a(t);
+	yield* n(t, r.table, r.schema), yield* n(t, r.marker, r.markerSchema);
+	let o = yield* t.executeUnprepared(`SELECT manifest,schema FROM main.${w(r.marker)}`, [], void 0);
+	if (o.length !== 1 || o[0]?.manifest !== r.manifest || o[0]?.schema !== JSON.stringify(r.receiptSchema)) return yield* d.fail(e("Stored decimal review ownership does not match its receipt"));
+	let s = yield* S(t, r.table);
+	if (JSON.stringify(s) !== JSON.stringify(r.witness) || (yield* a(t)) !== i) return yield* d.fail(e("Stored decimal review changed after acceptance"));
+}), b = (t, n, r, o) => d.gen(function* () {
+	let s = yield* p.SqlClient, l = yield* d.serviceOption(s.transactionService), u = (t) => d.fail(e(t));
+	if (f.isNone(l)) return yield* u("Decimal review coverage requires a pinned transaction");
+	let m = l.value[0], h = yield* a(m);
+	yield* v(t);
+	let g = 0;
+	if (yield* i(m, n, r, o, (n) => d.gen(function* () {
+		for (let r = 0; r < n.length; r += 128) {
+			let i = n.slice(r, r + 128), a = i.map(C), o = yield* m.executeUnprepared(`SELECT sort_key,payload,observation FROM main.${w(t.table)} WHERE sort_key IN (${a.map(() => "?").join(",")})`, a, void 0), s = new Map(o.map((e) => [e.sort_key, e]));
+			for (let t of i) {
+				let n = s.get(C(t));
+				if (!n) return yield* u("Decimal review is missing a retained source cell");
+				let r = yield* d.try({
+					try: () => JSON.parse(n.payload),
+					catch: (t) => e("Invalid stored decimal decision", t)
+				});
+				if (n.observation !== c(t.source) || r.target.precision !== t.target.precision || r.target.scale !== t.target.scale) return yield* u("Decimal review does not match the retained source cell");
+				g += 1;
+			}
+		}
+	})), g !== t.witness.cellCount) return yield* u("Decimal review contains cells outside the retained source");
+	if ((yield* a(m)) !== h) return yield* u("Decimal review changed during source coverage");
+}), x = (t, n) => d.gen(function* () {
+	let r = yield* p.SqlClient, i = yield* d.serviceOption(r.transactionService), o = (t) => d.fail(e(t));
+	if (f.isNone(i)) return yield* o("Decimal review row consumption requires a pinned transaction");
+	let s = i.value[0], c = yield* a(s);
+	yield* v(t);
+	let l, u = /* @__PURE__ */ new Map(), m = yield* S(s, t.table, (e) => d.gen(function* () {
+		l !== void 0 && l !== e.rowIdentity && (yield* n({
+			identity: l,
+			values: u
+		}), u = /* @__PURE__ */ new Map()), l = e.rowIdentity, u.set(e.column, e.encoded);
+	}));
+	if (l !== void 0 && (yield* n({
+		identity: l,
+		values: u
+	})), JSON.stringify(m) !== JSON.stringify(t.witness) || (yield* a(s)) !== c) return yield* o("Decimal review changed during row consumption");
+}), S = (t, n, r) => d.gen(function* () {
+	let i = (t) => e("Invalid stored decimal decision", t), a = l(), o;
+	for (;;) {
+		let e = o === void 0 ? "" : " WHERE sort_key > ? COLLATE BINARY", s = yield* t.executeUnprepared(`SELECT sort_key,payload,observation FROM main.${w(n)}${e} ORDER BY sort_key COLLATE BINARY LIMIT 256`, o === void 0 ? [] : [o], void 0);
+		if (s.length === 0) break;
+		for (let e of s) {
+			let t = yield* d.try({
+				try: () => {
+					let t = JSON.parse(e.payload);
+					if (e.payload !== JSON.stringify(t) || e.sort_key !== C(t)) throw TypeError("Noncanonical stored decision");
+					let n = JSON.parse(t.sourceIdentity);
+					if (e.observation !== JSON.stringify({
+						kind: n.kind,
+						observed: n.observed,
+						shape: n.shape
+					})) throw TypeError("Stored observation does not match the reviewed decision");
+					return a.append(t), t;
+				},
+				catch: i
+			});
+			r && (yield* r(t));
+		}
+		o = s[s.length - 1].sort_key;
+	}
+	return yield* d.try({
+		try: () => a.finish(),
+		catch: i
+	});
+}), C = (e) => Buffer.from(s(e), "utf16le").swap16().toString("hex"), w = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"";
+//#endregion
+export { x as forEachSqliteDecimalReviewRow, m as importSqliteDecimalReview, g as readSqliteDecimalReviewStore, h as reopenSqliteDecimalReview, b as verifySqliteDecimalReviewCoverage, v as verifySqliteDecimalReviewStore };

package/dist/migrations/sqliteDecimalReviewWitness.js

@@ -0,0 +1,38 @@
+import { normalizeSqliteDecimalCell as e, sqliteDecimalDecisionIdentity as t } from "./sqliteDecimalReview.js";
+import { createHash as n } from "node:crypto";
+//#region src/migrations/sqliteDecimalReviewWitness.ts
+var r = () => {
+	let e = n("sha256").update("["), r = 0, i, a = !1, o = !1;
+	return {
+		append(n) {
+			if (a) throw TypeError("Decimal review witness is already finalized");
+			if (o) throw TypeError("Decimal review witness contains invalid decisions");
+			let s = t(n);
+			if (i !== void 0 && s <= i) throw o = !0, TypeError("Decimal decisions require unique canonical order");
+			r > 0 && e.update(","), e.update(JSON.stringify(n)), i = s, r++;
+		},
+		finish() {
+			if (a) throw TypeError("Decimal review witness is already finalized");
+			if (o) throw TypeError("Decimal review witness contains invalid decisions");
+			return a = !0, {
+				version: 1,
+				cellCount: r,
+				digest: e.update("]").digest("hex")
+			};
+		}
+	};
+}, i = (t) => {
+	let n = t[Symbol.iterator](), i = r();
+	try {
+		for (;;) {
+			let t = n.next();
+			if (t.done) break;
+			i.append(e(t.value));
+		}
+		return i.finish();
+	} finally {
+		n.return?.();
+	}
+};
+//#endregion
+export { r as createSqliteDecimalReviewWitness, i as sqliteDecimalReviewInputWitness };