@voltro/runtime 0.85.0 → 0.87.0

package/dist/storeMiddleware.js

@@ -0,0 +1,882 @@
+import { isolateRawReadScope as e, rawSqlPreview as t, recordRawRead as n } from "./rawReadScope.js";
+import { applySealedWrite as r, assertCrdtUpdateAdmissible as i, mergeCrdtColumnsIntoPatch as a, patchTouchesCrdt as o } from "./crdtMerge.js";
+import { mapSetReadScopes as s } from "./setReadScopes.js";
+import { NO_ROW_FILTER as c, applyRowFilter as l, rowFilterRegistered as u } from "./rowFilter.js";
+import { addReadScopePredicate as d } from "./readScopePredicate.js";
+import { readMaybeOne as f } from "./storeRead.js";
+import { CRDT_VERSIONS_TABLE as p } from "./crdtVersionsTable.js";
+import { getFieldCipher as m } from "./fieldCipher.js";
+import { observeStore as h } from "./observedGraph.js";
+import { upsertConflictId as g } from "./upsertBinding.js";
+import { applyColumnOnUpdate as _ } from "./columnOnUpdate.js";
+import { prepareInsertRequiredColumns as v } from "./insertRequiredColumns.js";
+import { makeFluentStore as ee, missingRowError as te } from "./storeQuery.js";
+import { Schema as ne, SchemaIssue as re } from "effect";
+import { INITIAL_VERSION as ie, VersionConflict as ae, and as y, classifyConstraintViolation as oe, decryptFieldsOnRead as se, deserializeArraysOnRead as ce, encryptFieldsForWrite as le, encryptFieldsForWriteBatch as ue, encryptedColumnsOf as de, eq as b, extractDbCause as fe, generateId as pe, getRelations as me, getTable as x, gt as he, inSet as ge, isCompositeRowKey as _e, isNull as S, jsonPatchAssignments as ve, missingConflictColumns as ye, missingRequiredColumns as be, or as xe, planVersionedUpdate as Se, refuseIdChangeOfSealedRow as Ce, rowKeyColumns as we, rowKeyIdentity as C, serializeArraysForWrite as Te, settleVersionedUpdate as Ee, storeRefusalOf as De, upsertUpdateValues as Oe } from "@voltro/database";
+import { ConstraintViolation as ke, TableValidationFailed as w, TenantRowNotFound as Ae, TenantScopeViolation as je, ValidationError as Me, isMachineSubject as Ne, subjectAuditActorId as T } from "@voltro/protocol";
+import { createLogger as Pe } from "@voltro/logger";
+import { defaultCrdtBackend as E } from "@voltro/local-first";
+//#region src/storeMiddleware.ts
+var Fe = (e, t, n) => {
+	let r = me(e);
+	if (r === void 0) return t;
+	let i = {};
+	for (let [a, o] of Object.entries(t)) {
+		if (o === !1 || o === void 0) {
+			i[a] = o;
+			continue;
+		}
+		let t = r[a];
+		if (t === void 0) {
+			i[a] = o;
+			continue;
+		}
+		let s = t.through;
+		if (s !== void 0) {
+			let t;
+			try {
+				t = s().tableName;
+			} catch {
+				t = void 0;
+			}
+			if (t !== void 0 && n(t) !== void 0) throw Error(`row filter: the junction table '${t}' behind relation '${a}' on '${e}' is row-filtered, and a many-to-many junction is read below the seam that could narrow it — its rows would be joined unfiltered. Refusing the read rather than serving it.\n  → read '${t}' as its own query (it is filtered there), or\n  → drop '${a}' from this .with(...).`);
+		}
+		let c;
+		try {
+			c = t.target().tableName;
+		} catch {
+			c = void 0;
+		}
+		let l = o === !0 ? {} : { ...o };
+		if (c !== void 0) {
+			let e = n(c);
+			if (e !== void 0) {
+				let t = l.where;
+				l.where = t === void 0 ? e : y(t, e);
+			}
+			let t = l.with;
+			t !== void 0 && (l.with = Fe(c, t, n));
+		}
+		i[a] = l;
+	}
+	return i;
+}, D = "id", Ie = 3, O = 8, Le = (e) => "descriptor" in e ? e.descriptor : e, Re = (e, t) => {
+	let n = {};
+	for (let r of t) e[r] !== void 0 && (n[r] = e[r]);
+	return n;
+}, k = "cannot insert into tenant-scoped table without an authenticated tenant — subject.tenantId is null. Either authenticate first or pass tenantId explicitly in the row (admin tooling).", ze = (e) => {
+	throw new je({
+		table: e,
+		reason: k
+	});
+}, Be = (e) => T(e), Ve = (me, T) => {
+	let k = h(me);
+	e();
+	let A = Be(T.subject), M = T.subject.tenantId;
+	if (T.rowFilter === void 0 && !Ne(T.subject) && u()) throw Error("row filter registered, but this store was scoped without one — refusing to serve an unfiltered read.\n\nThis app called `setRowFilter`, so every scoped store must receive a resolved `rowFilter` (the serve pipeline's `withRowFilter` does this per request). Reaching here with none means a read path was built outside that spine, and continuing would serve rows the filter exists to hide — silently, which is how this was found in the first place.\n\nIf this path is deliberately unfiltered (a system sweep, a migration), pass `rowFilter: NO_ROW_FILTER` explicitly.");
+	let N = T.rowFilter ?? c, P = (e, t) => {
+		let n = { ...t }, r = T.schemaRegistry, i = r.idScheme(e);
+		if (i !== void 0 && n[D] == null) {
+			if (i.kind === "numeric") delete n[D];
+			else {
+				let t = pe(i, e);
+				t !== null && (n[D] = t);
+			}
+		}
+		let a = r.versionColumn(e);
+		if (a !== void 0) {
+			let e = n[a];
+			(typeof e != "number" || !Number.isFinite(e)) && (n[a] = ie);
+		}
+		if (r.hasAudit(e)) {
+			let e = /* @__PURE__ */ new Date();
+			"createdAt" in n || (n.createdAt = e), "updatedAt" in n || (n.updatedAt = e), A !== null && ("createdBy" in n || (n.createdBy = A), "updatedBy" in n || (n.updatedBy = A));
+		}
+		r.hasTenant(e) && ("tenantId" in n || (M === null && ze(e), n.tenantId = M));
+		let o = r.defaultFactories(e);
+		if (o.size > 0) for (let [e, t] of o) (!(e in n) || n[e] === void 0) && (n[e] = t());
+		let s = r.computedFields(e);
+		if (s.size > 0) for (let [e, t] of s) n[e] = t(n);
+		let c = r.generatedColumns(e);
+		if (c.size > 0) for (let e of c) delete n[e];
+		return n;
+	}, F = (e, t, n = []) => {
+		let r = _(T.schemaRegistry, e, t, n);
+		if (!T.schemaRegistry.hasAudit(e)) return r;
+		let i = { ...r };
+		return "updatedAt" in i || (i.updatedAt = /* @__PURE__ */ new Date()), A !== null && !("updatedBy" in i) && (i.updatedBy = A), i;
+	}, I = async (e, t, n, r) => {
+		try {
+			return await r();
+		} catch (r) {
+			let i = De(r);
+			if (i !== void 0) throw new ke({
+				kind: i.kind,
+				table: e,
+				operation: t,
+				...i.constraint === void 0 ? {} : { constraint: i.constraint },
+				...i.column === void 0 ? {} : { column: i.column },
+				detail: i.detail
+			});
+			let a = fe(r), o = oe(a, t);
+			if (o === void 0) throw r;
+			if (T.schemaRegistry.hasTenant(e) && (o.kind === "foreignKey" || o.kind === "foreignKeyInUse")) {
+				let t = n?.tenantId, r = `${a.dbConstraint ?? ""} ${a.dbColumn ?? ""} ${a.dbMessage ?? ""} ${a.dbCauseChain ?? ""}`.toLowerCase();
+				if (r.includes("tenantid") || /\btenants\b/.test(r) || t != null && r.includes(String(t).toLowerCase())) throw new je({
+					table: e,
+					reason: t == null ? "write references a tenant that does not exist" : `tenant '${String(t)}' does not exist — seed the row in \`tenants\`, or fix how the request resolved this tenant (subject.tenantId / the x-tenant header / the dev TENANT fallback)`
+				});
+			}
+			throw new ke({
+				kind: o.kind,
+				table: e,
+				operation: t,
+				...o.constraint === void 0 ? {} : { constraint: o.constraint },
+				...o.column === void 0 ? {} : { column: o.column }
+			});
+		}
+	}, He = (e, t, n) => {
+		let r = T.schemaRegistry.computedFields(e);
+		if (r.size === 0) return n;
+		let i = {
+			...t,
+			...n
+		}, a = { ...n };
+		for (let [e, t] of r) a[e] = t(i);
+		return a;
+	}, L = (e, t) => {
+		let n = T.schemaRegistry.validatePatchSchema(e);
+		if (n === void 0) return t;
+		let r = ne.decodeUnknownResult(n)(t);
+		if (r._tag === "Success") return t;
+		let i = re.makeFormatterStandardSchemaV1()(r.failure.issue).issues.map((e) => ({
+			path: (e.path ?? []).length === 0 ? "<root>" : (e.path ?? []).join("."),
+			message: e.message
+		})), a = i[0];
+		throw new w({
+			table: e,
+			summary: a === void 0 ? "patch validation failed" : `${a.path}: ${a.message}`,
+			issues: i
+		});
+	}, Ue = () => {
+		let e = { deletedAt: /* @__PURE__ */ new Date() };
+		return A !== null && (e.deletedBy = A), e;
+	}, We = (e, t, n) => {
+		let r = ye(x(e), n, t);
+		if (r.length !== 0) throw new w({
+			table: e,
+			summary: `upsert conflictColumns [${n.map((e) => `'${e}'`).join(", ")}] cannot match: ` + r.map((e) => e.reason === "null" ? `'${e.column}' is NULL` : `'${e.column}' is absent`).join(", "),
+			issues: r.map((e) => ({
+				path: e.column,
+				message: e.reason === "null" ? "named in conflictColumns but NULL — NULL never matches a unique conflict target, so this write would always INSERT. Use a plain insert for NULL-keyed rows, or make the column NOT NULL." : "named in conflictColumns but absent from the payload"
+			}))
+		});
+	}, R = (e, t, n) => {
+		let i = T.schemaRegistry.crdtColumns(e);
+		o(i, t) && (t = a(i, void 0, t, e));
+		for (let n of T.schemaRegistry.sealedColumns(e)) {
+			let i = t[n];
+			i instanceof Uint8Array && (t = {
+				...t,
+				[n]: r(e, n, void 0, i).log
+			});
+		}
+		let s = x(e);
+		if (s !== void 0) {
+			let r = n === void 0 ? be(s, t) : n.filter((e) => t[e] === void 0 || t[e] === null);
+			if (r.length > 0) throw new w({
+				table: e,
+				summary: `missing required column${r.length > 1 ? "s" : ""} ${r.map((e) => `'${e}'`).join(", ")} — NOT NULL with no default and not auto-stamped`,
+				issues: r.map((e) => ({
+					path: e,
+					message: "required (NOT NULL, no default) but absent from the payload"
+				}))
+			});
+		}
+		let c = T.schemaRegistry.insertSchema(e);
+		if (c === void 0) return t;
+		let l = ne.decodeUnknownResult(c)(t);
+		if (l._tag === "Success") return t;
+		let u = re.makeFormatterStandardSchemaV1()(l.failure.issue).issues.map((e) => ({
+			path: (e.path ?? []).length === 0 ? "<root>" : (e.path ?? []).join("."),
+			message: e.message
+		})), d = u[0];
+		throw new w({
+			table: e,
+			summary: d === void 0 ? "row validation failed" : `${d.path}: ${d.message}`,
+			issues: u
+		});
+	}, z = T.dialect, B = (e, t, n) => {
+		let r = x(e), i = z ? Te(t, r, z) : t;
+		return le(i, r, m(), n);
+	}, V = (e, t, n) => (Ce(t, x(e), n), B(e, t, n)), H = (e, t) => {
+		let n = x(e);
+		return n !== void 0 && de(n).some((e) => t[e] !== void 0 && t[e] !== null);
+	}, Ge = (e) => {
+		let t = e.projection;
+		if (t === void 0 || t.includes(D)) return {
+			descriptor: e,
+			stripId: !1
+		};
+		let n = x(e.table);
+		return n === void 0 || de(n).length === 0 ? {
+			descriptor: e,
+			stripId: !1
+		} : {
+			descriptor: {
+				...e,
+				projection: [...t, D]
+			},
+			stripId: !0
+		};
+	}, Ke = process.env.VOLTRO_FIELD_DECRYPT_ON_ERROR === "null" ? "null" : "throw", qe = Pe({ scope: "store.fieldEncryption" }), Je = /* @__PURE__ */ new Set(), Ye = (e) => {
+		let t = `${e.table}.${e.column}`;
+		Je.has(t) || (Je.add(t), qe.warn("encrypted column degraded to null — could not decrypt with the active key", {
+			table: e.table,
+			column: e.column,
+			reason: e.reason,
+			hint: "VOLTRO_FIELD_DECRYPT_ON_ERROR=null is set — this row was likely encrypted under a different key"
+		}));
+	}, U = (e, t, n) => {
+		let r = x(e), i = se(t, r, m(), {
+			onError: Ke,
+			...Ke === "null" ? { warn: Ye } : {},
+			...n === void 0 ? {} : { rowId: n }
+		});
+		return z ? ce(i, r, z) : i;
+	}, Xe = (e, t, n = N) => {
+		let r = e, i = r.table;
+		!r.crossTenant && M != null && T.schemaRegistry.hasTenant(i) && (r = d(r, (e) => b(e("tenantId"), M))), !r.includeDeleted && T.schemaRegistry.hasSoftDelete(i) && (r = d(r, (e) => S(e("deletedAt")))), !r.includeExpired && T.schemaRegistry.hasExpires(i) && (r = d(r, (e) => xe(S(e("expiresAt")), he(e("expiresAt"), t))));
+		let a = r.predicate;
+		a = l(n, i, a);
+		let o = r.eager === void 0 ? void 0 : Fe(i, r.eager, n);
+		return o === void 0 ? a === r.predicate ? r : {
+			...r,
+			predicate: a
+		} : {
+			...r,
+			predicate: a,
+			eager: o
+		};
+	}, Ze = (e, t = N) => {
+		let n = /* @__PURE__ */ new Date();
+		return s(e, (e) => Xe(e, n, t));
+	}, Qe = async (e, t, n) => {
+		let r = Ge(e), i = await t(r.descriptor), a = U(e.table, i);
+		return n && et(e.table, a), r.stripId ? a.map((e) => {
+			let { [D]: t, ...n } = e;
+			return n;
+		}) : a;
+	}, $e = (e) => Qe(e, k.query.bind(k), !0), W = (e) => $e(Ze(e)), G = (e, t, n) => {
+		if (_e(n)) return;
+		let r = T.schemaRegistry.declaredPrimaryKey(e);
+		if (r.length === 0 || r.length === 1 && r[0] === "id") return;
+		let i = r.map((e) => `${e}: …`).join(", ");
+		throw Error(`${t}('${e}', <${typeof n}>, …) cannot address a row: '${e}' has no \`id\` column — its primary key is (${r.join(", ")}). Pass those columns instead:\n    store.${t}('${e}', { ${i} }${t === "delete" ? "" : ", patch"})\nThis used to return ${t === "delete" ? "`false`" : "`null`"}, which is also what a missing row returns.`);
+	}, K = async (e, t) => {
+		if (M === null || !T.schemaRegistry.hasTenant(e)) return;
+		let n = we(t).map(([e, t]) => b(e, t)).reduce((e, t) => e === void 0 ? t : y(e, t), void 0);
+		if (!((await k.query({
+			table: e,
+			lock: "update",
+			predicate: y(n, b("tenantId", M)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: we(t).map(([e]) => e)
+		})).length > 0)) throw new Ae({
+			table: e,
+			id: C(t),
+			reason: "no row with this id in your tenant — it does not exist, or it belongs to another tenant. These are deliberately indistinguishable: reporting them differently would let a caller probe for row ids in other tenants."
+		});
+	}, q = Symbol.for("@voltro/runtime:tx-fold-releases"), J = Symbol.for("@voltro/runtime:tx-read-versions"), Y = (e) => e[J], X = (e, t) => `${e}\u0000${String(t)}`, et = (e, t) => {
+		let n = Y(k);
+		if (n === void 0 || t.length === 0) return;
+		let r = T.schemaRegistry.versionColumn(e);
+		if (r !== void 0) for (let i of t) {
+			let t = i[D], a = i[r];
+			typeof t == "string" && typeof a == "number" && Number.isFinite(a) && n.set(X(e, t), a);
+		}
+	}, Z = (() => {
+		let e = globalThis, t = Symbol.for("@voltro/runtime:crdt-fold-locks");
+		return e[t] ??= /* @__PURE__ */ new Map();
+	})(), tt = async (e, t, n) => {
+		let r = `${e}\u0000${C(t)}`, i = Z.get(r) ?? Promise.resolve(), a, o = new Promise((e) => {
+			a = e;
+		});
+		Z.set(r, i.then(() => o)), await i;
+		try {
+			return await n();
+		} finally {
+			a(), Z.get(r) === o && Z.delete(r);
+		}
+	}, Q = async (e, t, n) => {
+		let r = T.schemaRegistry.sealedColumns(e);
+		if (o(r, n)) {
+			let i = {}, a = {};
+			for (let [e, t] of Object.entries(n)) (r.has(e) ? i : a)[e] = t;
+			let o = await at(e, t, i);
+			return o === null || Object.keys(a).length === 0 ? o : Q(e, t, a);
+		}
+		let a = T.schemaRegistry.crdtColumns(e);
+		if (o(a, n)) {
+			for (let t of a) t in n && i(e, t, n[t]);
+			let r = k[q];
+			if (r !== void 0) {
+				let i = {}, o = {};
+				for (let [e, t] of Object.entries(n)) a.has(e) ? i[e] = t : o[e] = t;
+				if (r.push({
+					table: e,
+					pk: t,
+					patch: i
+				}), Object.keys(o).length > 0) return $(e, t, o);
+				await K(e, t);
+				let s = await k.query({
+					table: e,
+					predicate: {
+						column: D,
+						op: "eq",
+						value: t
+					},
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				});
+				return s[0] === void 0 ? null : U(e, [s[0]])[0];
+			}
+			return tt(e, t, () => $(e, t, n));
+		}
+		return $(e, t, n);
+	}, $ = async (e, t, n) => {
+		G(e, "update", t), await K(e, t);
+		let r = F(e, n), i = T.schemaRegistry.crdtColumns(e);
+		if (o(i, r)) return ot(e, t, r, i);
+		if (T.schemaRegistry.computedFields(e).size > 0) {
+			let n = (await k.query({
+				table: e,
+				predicate: {
+					column: D,
+					op: "eq",
+					value: t
+				},
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0];
+			if (n === void 0) return null;
+			let i = U(e, [n])[0];
+			r = He(e, i, r);
+		}
+		r = L(e, r);
+		let a = T.schemaRegistry.versionColumn(e), s;
+		if (a !== void 0) {
+			let n = Se({
+				versionColumn: a,
+				patch: r
+			}), i = Y(k)?.get(X(e, C(t))), o = n.expected === void 0 && i !== void 0, c = n.expected ?? i, l = (e) => {
+				throw o ? new j(e) : e;
+			}, u = async () => {
+				let n = await k.query({
+					table: e,
+					predicate: {
+						column: D,
+						op: "eq",
+						value: t
+					},
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				}), r = n[0] === void 0 ? void 0 : n[0][a];
+				return typeof r == "number" && Number.isFinite(r) ? r : null;
+			}, d = await u(), f = Ee({
+				table: e,
+				id: C(t),
+				expected: c,
+				current: d
+			});
+			if (f !== void 0 && l(f), d === null) return null;
+			s = null;
+			for (let i = 0;; i += 1) {
+				let o = d;
+				if (r = {
+					...n.patch,
+					[a]: o + 1
+				}, await I(e, "update", r, () => k.updateMany(e, V(e, r, t), { where: y(b(D, t), b(a, o)) })) > 0) {
+					s = (await k.query({
+						table: e,
+						predicate: {
+							column: D,
+							op: "eq",
+							value: t
+						},
+						order: [],
+						take: 1,
+						skip: void 0,
+						projection: void 0
+					}))[0] ?? null, Y(k)?.set(X(e, C(t)), o + 1);
+					break;
+				}
+				let f = await u();
+				(c !== void 0 || f === null || i >= Ie) && l(new ae({
+					table: e,
+					id: C(t),
+					expected: c ?? o,
+					actual: f
+				})), d = f;
+			}
+		} else s = await I(e, "update", r, () => k.update(e, t, V(e, r, t)));
+		return s === null ? null : U(e, [s], t)[0];
+	}, nt = async (e, t, n) => {
+		let r = await k.query({
+			table: p,
+			predicate: y(b("tableName", e), b("rowId", C(t)), b("columnName", n), b("reason", "rebase")),
+			order: [{
+				column: "createdAt",
+				direction: "desc"
+			}],
+			take: void 0,
+			skip: void 0,
+			projection: void 0
+		});
+		return U(p, r).map((e) => e.state).filter((e) => e instanceof Uint8Array);
+	}, rt = async (e, t, n, r, i) => {
+		let a = P(p, {
+			tableName: e,
+			rowId: C(t),
+			columnName: n,
+			state: r,
+			reason: "rebase",
+			label: null,
+			epoch: i === void 0 ? E.epochOf(r) ?? null : i,
+			createdBy: null
+		});
+		await I(p, "insert", a, () => k.insert(p, B(p, R(p, a))));
+	}, it = async (e, t, n, r, i) => {
+		if (!(r instanceof Uint8Array) || !(i instanceof Uint8Array) || r.length === 0) return i;
+		let a = E.authorsOf(r), o = [...E.authorsOf(i)].filter((e) => !a.has(e));
+		if (o.length === 0 || E.epochOf(r) === void 0) return i;
+		for (let a of await nt(e, t, n)) {
+			let t = E.authorsOf(a);
+			if (!o.some((e) => t.has(e))) continue;
+			let s = E.translate(a, i, r);
+			if (s === void 0) throw new Me({
+				field: n,
+				message: "crdt.staleLineage",
+				params: { table: e }
+			});
+			return s;
+		}
+		return i;
+	}, at = async (e, t, n) => {
+		await K(e, t);
+		for (let i = 0;; i += 1) {
+			let a = (await k.query({
+				table: e,
+				predicate: {
+					column: D,
+					op: "eq",
+					value: t
+				},
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0];
+			if (a === void 0) return null;
+			let o = U(e, [a])[0], s = {}, c = [b(D, t)], l = [];
+			for (let [t, i] of Object.entries(n)) {
+				if (i === null) s[t] = null;
+				else {
+					let n = r(e, t, o[t], i);
+					s[t] = n.log, n.replaced !== void 0 && l.push({
+						column: t,
+						...n.replaced
+					});
+				}
+				let n = a[t];
+				c.push(n == null ? S(t) : b(t, n));
+			}
+			let u = F(e, s);
+			if (await I(e, "update", u, () => k.updateMany(e, V(e, u, t), { where: y(...c) })) > 0) {
+				for (let n of l) await rt(e, t, n.column, n.log, n.epoch === "" ? null : n.epoch);
+				let n = await k.query({
+					table: e,
+					predicate: {
+						column: D,
+						op: "eq",
+						value: t
+					},
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				});
+				return n[0] === void 0 ? null : U(e, [n[0]], t)[0];
+			}
+			if (i + 1 >= O) throw Error(`sealed crdt append on ${e} lost ${O} compare-and-swap rounds to concurrent writers; the frame was not written and can be retried`);
+			await new Promise((e) => setTimeout(e, Math.random() * 5 * (i + 1)));
+		}
+	}, ot = async (e, t, n, r) => {
+		let i = async () => (await k.query({
+			table: e,
+			predicate: {
+				column: D,
+				op: "eq",
+				value: t
+			},
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0], o = [...r].filter((e) => e in n), s = T.schemaRegistry.versionColumn(e), c = s === void 0 ? void 0 : Se({
+			versionColumn: s,
+			patch: n
+		}), l = s === void 0 ? void 0 : Y(k)?.get(X(e, C(t))), u = c !== void 0 && c.expected === void 0 && l !== void 0, d = c?.expected ?? l, f = c?.patch ?? n, p = await i();
+		for (let n = 0;; n += 1) {
+			if (p === void 0) return null;
+			let c = U(e, [p])[0], l = f;
+			for (let n of o) {
+				let r = await it(e, t, n, c[n], f[n]);
+				r !== f[n] && (l = {
+					...l,
+					[n]: r
+				});
+			}
+			let m = [], h = a(r, c, l, e, (e, t) => {
+				m.push({
+					column: e,
+					archived: t
+				});
+			});
+			T.schemaRegistry.computedFields(e).size > 0 && (h = He(e, c, h));
+			let g = [b(D, t)];
+			for (let e of o) {
+				let t = p[e];
+				g.push(t == null ? S(e) : b(e, t));
+			}
+			let _;
+			if (s !== void 0) {
+				let n = p[s];
+				_ = typeof n == "number" && Number.isFinite(n) ? n : void 0;
+				let r = Ee({
+					table: e,
+					id: C(t),
+					expected: d,
+					current: _ ?? null
+				});
+				if (r !== void 0) throw u ? new j(r) : r;
+				_ !== void 0 && (h = {
+					...h,
+					[s]: _ + 1
+				}, g.push(b(s, _)));
+			}
+			h = L(e, h);
+			let v = h;
+			if (await I(e, "update", v, () => k.updateMany(e, V(e, v, t), { where: y(...g) })) > 0) {
+				for (let { column: n, archived: r } of m) await rt(e, t, n, r);
+				let n = await i();
+				return n === void 0 ? null : (s !== void 0 && _ !== void 0 && Y(k)?.set(X(e, C(t)), _ + 1), U(e, [n], t)[0]);
+			}
+			if (n + 1 >= O) throw Error(`crdt fold on ${e} lost ${O} compare-and-swap rounds to concurrent writers; the update was not written and can be retried`);
+			await new Promise((e) => setTimeout(e, Math.random() * 5 * (n + 1))), p = await i();
+		}
+	}, st = async (e, t) => (G(e, "delete", t), await K(e, t), T.schemaRegistry.hasSoftDelete(e) ? await Q(e, t, Ue()) !== null : I(e, "delete", void 0, () => k.delete(e, t))), ct = async (e, t, n) => {
+		let r = F(e, t), i = T.schemaRegistry.versionColumn(e);
+		if (i === void 0) {
+			if (!H(e, r)) return I(e, "updateMany", r, () => k.updateMany(e, B(e, r), n));
+			let t = await k.query({
+				table: e,
+				predicate: n.where,
+				order: [],
+				take: void 0,
+				skip: void 0,
+				projection: [D]
+			}), i = 0;
+			for (let a of t) {
+				let t = a[D];
+				t != null && (i += await I(e, "updateMany", r, () => k.updateMany(e, V(e, r, t), { where: y(n.where, b(D, t)) })));
+			}
+			return i;
+		}
+		let a = await k.query({
+			table: e,
+			predicate: n.where,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: [D, i]
+		}), { [i]: o, ...s } = r, c = 0;
+		for (let t of a) {
+			let r = t[D];
+			if (typeof r != "string") continue;
+			let a = t[i];
+			for (let t = 0; typeof a == "number" && Number.isFinite(a); t += 1) {
+				let o = a, l = {
+					...s,
+					[i]: o + 1
+				}, u = await I(e, "updateMany", l, () => k.updateMany(e, V(e, l, r), { where: y(n.where, b(D, r), b(i, o)) }));
+				if (u > 0) {
+					c += u;
+					break;
+				}
+				if (t >= Ie) throw new ae({
+					table: e,
+					id: r,
+					expected: o,
+					actual: null
+				});
+				a = (await k.query({
+					table: e,
+					predicate: y(n.where, b(D, r)),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: [i]
+				}))[0]?.[i];
+			}
+		}
+		return c;
+	}, lt = async (e, t) => I(e, "deleteMany", void 0, () => k.deleteMany(e, t)), ut = (e, t) => M != null && T.schemaRegistry.hasTenant(e) ? y(t, b("tenantId", M)) : t, dt = async (e, t, n) => ct(e, t, {
+		...n,
+		where: ut(e, n.where)
+	}), ft = async (e, t) => lt(e, {
+		...t,
+		where: ut(e, t.where)
+	}), pt = ee({
+		query: $e,
+		updateMany: ct,
+		deleteMany: lt,
+		delete: (e, t) => k.delete(e, t)
+	}, {
+		subject: T.subject,
+		schemaRegistry: T.schemaRegistry,
+		rowFilter: N
+	}), mt = ((e, t, n) => t === void 0 ? pt.updateWhere(e) : Q(e, t, n)), ht = ((e, t) => t === void 0 ? pt.deleteWhere(e) : st(e, t)), gt = async (e, t, n) => {
+		let r = t.map((t) => P(e, t)), i = x(e), a = t.length >= 32 && i !== void 0 && T.schemaRegistry.insertSchema(e) === void 0 && T.schemaRegistry.crdtColumns(e).size === 0 && T.schemaRegistry.sealedColumns(e).size === 0 ? v(i) : void 0, o = r.map((t) => R(e, t, a)), s = z ? o.map((e) => Te(e, i, z)) : o, c = ue(s, i, m()), l = await I(e, "insertMany", r[0], () => k.insertMany(e, c, n));
+		return U(e, l);
+	}, _t = (e, t) => {
+		let n = Object.keys(t);
+		if (n.length !== 1) throw Error(`store.links('${e}'): anchor must name exactly one source column, got [${n.join(", ")}]`);
+		let r = n[0], i = t[r], a = x(e);
+		if (a === void 0) throw Error(`store.links('${e}'): unknown table (not registered) — declare it and its relation first`);
+		let o = Object.entries(a.fields).filter(([, e]) => e.type === "reference").map(([e]) => e);
+		if (o.length !== 2) throw Error(`store.links('${e}'): expected a junction with exactly two reference() columns, found ${o.length} [${o.join(", ")}]. Use plain insert/deleteMany for a non-standard junction.`);
+		if (!o.includes(r)) throw Error(`store.links('${e}'): '${r}' is not a reference column of the junction [${o.join(", ")}]`);
+		return {
+			sourceCol: r,
+			sourceId: i,
+			targetCol: o.find((e) => e !== r)
+		};
+	}, vt = (e, t) => {
+		let n = x(e);
+		if (n === void 0) throw Error(`store.relationLinks('${e}'): unknown table (not registered) — declare it and its relation first`);
+		let r = Object.entries(n.fields).filter(([, e]) => e.type === "reference").filter(([, e]) => {
+			let n = e.references;
+			try {
+				return n !== void 0 && n().tableName === t;
+			} catch {
+				return !1;
+			}
+		}).map(([e]) => e);
+		if (r.length === 1) return r[0];
+		throw r.length === 0 ? Error(`store.relationLinks('${e}'): no reference column points at '${t}' — the junction's reference() targets decide the anchor, and none matches.`) : Error(`store.relationLinks('${e}'): ${r.length} reference columns point at '${t}' [${r.join(", ")}] — a self-junction is ambiguous; use store.links('${e}', { <column>: id }) and name the side.`);
+	}, yt = (e, t) => {
+		let { sourceCol: n, sourceId: r, targetCol: i } = _t(e, t), a = async () => (await W({
+			table: e,
+			predicate: b(n, r),
+			order: [],
+			projection: void 0,
+			skip: void 0,
+			take: void 0
+		})).map((e) => String(e[i])), o = async (t) => {
+			t.length !== 0 && await gt(e, t.map((e) => ({
+				[n]: r,
+				[i]: e
+			})), { returning: "none" });
+		}, s = async (t) => {
+			t.length !== 0 && await ft(e, { where: y(b(n, r), ge(i, t)) });
+		};
+		return {
+			columns: {
+				anchorColumn: n,
+				targetColumn: i
+			},
+			list: a,
+			set: async (e) => {
+				let t = new Set(e), n = new Set(await a()), r = [...t].filter((e) => !n.has(e)), i = [...n].filter((e) => !t.has(e));
+				return await s(i), await o(r), {
+					added: r,
+					removed: i
+				};
+			},
+			add: async (e) => {
+				let t = new Set(await a()), n = [...new Set(e)].filter((e) => !t.has(e));
+				return await o(n), n;
+			},
+			remove: async (e) => {
+				let t = new Set(await a()), n = [...new Set(e)].filter((e) => t.has(e));
+				return await s(n), n;
+			},
+			setRows: async (t) => {
+				let a = /* @__PURE__ */ new Map(), o = await W({
+					table: e,
+					predicate: b(n, r),
+					order: [],
+					projection: void 0,
+					skip: void 0,
+					take: void 0
+				});
+				for (let e of o) a.set(String(e[i]), e);
+				let c = /* @__PURE__ */ new Map();
+				for (let e of t) c.set(String(e[i]), e);
+				let l = [...a.keys()].filter((e) => !c.has(e));
+				await s(l);
+				let u = [], d = [], f = [];
+				for (let [t, o] of c) if (!a.has(t)) u.push(t), f.push({
+					...o,
+					[n]: r,
+					[i]: t
+				});
+				else {
+					let s = a.get(t), c = {}, l = !1;
+					for (let [e, t] of Object.entries(o)) e !== n && e !== i && s[e] !== t && (c[e] = t, l = !0);
+					l && (d.push(t), await dt(e, c, { where: y(b(n, r), b(i, t)) }));
+				}
+				return f.length > 0 && await gt(e, f, { returning: "none" }), {
+					added: u,
+					removed: l,
+					updated: d
+				};
+			}
+		};
+	}, bt = async (e, t, n, r) => {
+		let i = t[D] !== void 0 && t[D] !== null, a = P(e, t), o = Oe(n), s = n;
+		if (We(e, a, n.conflictColumns), typeof n.update == "function") {
+			let t = n.update;
+			s = {
+				conflictColumns: n.conflictColumns,
+				update: (n) => {
+					let r = n.id, i = U(e, [n], r)[0], a = F(e, {
+						...t(i),
+						...o
+					});
+					return V(e, L(e, a), r);
+				}
+			};
+		} else {
+			let r = n.update ?? Object.keys(t).filter((t) => t !== "id" && !n.conflictColumns.includes(t) && (!T.schemaRegistry.hasAudit(e) || t !== "createdAt" && t !== "createdBy"));
+			s = {
+				...n,
+				update: r
+			};
+			let i = {
+				...Object.fromEntries(r.filter((e) => e in t).map((e) => [e, t[e]])),
+				...o
+			}, a = F(e, i);
+			o = Oe({
+				conflictColumns: n.conflictColumns,
+				updateValues: {
+					...o,
+					...Object.fromEntries(Object.entries(a).filter(([e]) => i[e] === void 0))
+				}
+			});
+		}
+		let c = !i && typeof a[D] == "string" ? a[D] : void 0, l = H(e, a) || H(e, o) || r && c === void 0, u = l ? await g(k, e, a, n.conflictColumns) : void 0, d = l ? u === void 0 ? a[D] : u : void 0, f = l ? u === void 0 ? "inserted" : "updated" : void 0, p = await I(e, "upsert", a, () => k.upsert(e, B(e, R(e, a), d), {
+			...s,
+			...typeof n.update != "function" && (n.updateValues !== void 0 || Object.keys(o).length > 0) ? { updateValues: B(e, L(e, o), d) } : {}
+		}));
+		return {
+			row: U(e, [p], d)[0],
+			outcome: f ?? (c !== void 0 && p[D] !== c ? "updated" : "inserted")
+		};
+	}, xt = async (e, t, n) => {
+		let r = P(e, t);
+		We(e, r, n.conflictColumns);
+		let i = await I(e, "insertIgnore", r, () => k.insertIgnoreWithOutcome(e, B(e, R(e, r)), n));
+		return {
+			row: U(e, [i.row])[0],
+			outcome: i.outcome
+		};
+	};
+	return {
+		query: W,
+		...k.integrityQuery === void 0 ? {} : { integrityQuery: (e) => Qe(Ze({
+			...e,
+			crossTenant: !1,
+			includeDeleted: !1,
+			includeExpired: !1
+		}, c), k.integrityQuery.bind(k), !1) },
+		one: (async (e, t) => {
+			let n = Le(e), r = await W({
+				...n,
+				take: 2
+			}), i = r[0];
+			if (i === void 0) throw te({
+				table: n.table,
+				found: 0
+			}, t);
+			if (r.length > 1) throw te({
+				table: n.table,
+				found: r.length
+			}, t);
+			return i;
+		}),
+		first: ((e) => f({ query: W }, e)),
+		maybeOne: ((e) => f({ query: W }, e)),
+		insert: async (e, t) => {
+			let n = P(e, t), r = await I(e, "insert", n, () => k.insert(e, B(e, R(e, n))));
+			return U(e, [r])[0];
+		},
+		insertMany: (async (e, t, n) => gt(e, t, n)),
+		links: yt,
+		relationLinks: (e, t, n) => yt(e, { [vt(e, t)]: n }),
+		patchJson: async (e, t, n, r, i) => {
+			G(e, "patchJson", t), await K(e, t);
+			let a = ve(t, n, F(e, ve(t, n, i), [n.split(".")[0]])), o = await I(e, "patchJson", a, () => k.patchJson(e, t, n, r, V(e, L(e, a), t)));
+			return o === null ? null : U(e, [o], t)[0];
+		},
+		select: pt.select,
+		update: mt,
+		delete: ht,
+		applyDefined: Re,
+		hardDelete: async (e, t) => (G(e, "hardDelete", t), await K(e, t), I(e, "hardDelete", void 0, () => k.delete(e, t))),
+		updateMany: dt,
+		deleteMany: ft,
+		upsert: async (e, t, n) => (await bt(e, t, n, !1)).row,
+		upsertWithOutcome: (e, t, n) => bt(e, t, n, !0),
+		insertIgnore: async (e, t, n) => (await xt(e, t, n)).row,
+		insertIgnoreWithOutcome: (e, t, n) => xt(e, t, n),
+		transactional: async (e) => {
+			let t = await k.transactional(async (t) => {
+				let n = [];
+				return t[q] = n, t[J] = /* @__PURE__ */ new Map(), {
+					result: await e(Ve(t, T)),
+					jobs: n
+				};
+			});
+			for (let e of t.jobs) await Q(e.table, e.pk, e.patch);
+			return t.result;
+		},
+		...k.raw ? { raw: ((e, r) => (n(Object.freeze({
+			sql: t(e.strings),
+			dependsOn: r?.dependsOn ?? e.dependsOn ?? []
+		})), k.raw(e, r))) } : {},
+		...k.savepoint ? { savepoint: (e) => k.savepoint(e) } : {},
+		onChange: (e) => k.onChange(e),
+		injectExternalChange: (e) => k.injectExternalChange(e),
+		...k.changeScope === void 0 ? {} : { changeScope: k.changeScope },
+		...k[q] === void 0 ? {} : { [q]: k[q] },
+		...Y(k) === void 0 ? {} : { [J]: Y(k) }
+	};
+}, A = "VoltroTransactionReadConflict", j = class extends Error {
+	conflict;
+	name = A;
+	constructor(e) {
+		super(e.message), this.conflict = e;
+	}
+}, M = (e) => typeof e == "object" && !!e && e.name === "VoltroTransactionReadConflict" && "conflict" in e, N = Symbol.for("@voltro/runtime:tx-read-versions");
+//#endregion
+export { A as TRANSACTION_READ_CONFLICT_NAME, N as TX_READ_VERSIONS_KEY, j as TransactionReadConflict, Be as actingUserId, Re as applyDefined, M as isTransactionReadConflict, Ve as wrapStoreWithMixinBehaviour };