@voltro/runtime 0.85.0 → 0.86.0

package/dist/storeMiddleware.js

@@ -0,0 +1,880 @@
+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 { NO_ROW_FILTER as s, applyRowFilter as c, rowFilterRegistered as l } from "./rowFilter.js";
+import { readMaybeOne as u } from "./storeRead.js";
+import { CRDT_VERSIONS_TABLE as d } from "./crdtVersionsTable.js";
+import { getFieldCipher as f } from "./fieldCipher.js";
+import { observeStore as p } from "./observedGraph.js";
+import { upsertConflictId as m } from "./upsertBinding.js";
+import { applyColumnOnUpdate as h } from "./columnOnUpdate.js";
+import { prepareInsertRequiredColumns as g } from "./insertRequiredColumns.js";
+import { makeFluentStore as _, missingRowError as v } from "./storeQuery.js";
+import { Schema as ee, SchemaIssue as te } from "effect";
+import { INITIAL_VERSION as ne, VersionConflict as re, and as y, classifyConstraintViolation as ie, decryptFieldsOnRead as ae, deserializeArraysOnRead as oe, encryptFieldsForWrite as se, encryptFieldsForWriteBatch as ce, encryptedColumnsOf as le, eq as b, extractDbCause as ue, generateId as de, getRelations as fe, getTable as x, gt as pe, inSet as me, isCompositeRowKey as he, isNull as S, jsonPatchAssignments as ge, missingConflictColumns as _e, missingRequiredColumns as ve, or as ye, planVersionedUpdate as be, rowKeyColumns as xe, rowKeyIdentity as C, serializeArraysForWrite as Se, settleVersionedUpdate as Ce, storeRefusalOf as we, upsertUpdateValues as Te } from "@voltro/database";
+import { ConstraintViolation as Ee, TableValidationFailed as w, TenantRowNotFound as De, TenantScopeViolation as Oe, ValidationError as ke, isMachineSubject as Ae, subjectAuditActorId as T } from "@voltro/protocol";
+import { createLogger as je } from "@voltro/logger";
+import { defaultCrdtBackend as E } from "@voltro/local-first";
+//#region src/storeMiddleware.ts
+var Me = (e, t, n) => {
+	let r = fe(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 = Me(c, t, n));
+		}
+		i[a] = l;
+	}
+	return i;
+}, D = "id", Ne = 3, O = 8, Pe = (e) => "descriptor" in e ? e.descriptor : e, Fe = (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).", Ie = (e) => {
+	throw new Oe({
+		table: e,
+		reason: k
+	});
+}, Le = (e) => T(e), Re = (fe, T) => {
+	let k = p(fe);
+	e();
+	let A = Le(T.subject), M = T.subject.tenantId;
+	if (T.rowFilter === void 0 && !Ae(T.subject) && l()) 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 ?? s, 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 = de(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] = ne);
+		}
+		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 && Ie(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 = h(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 = we(r);
+			if (i !== void 0) throw new Ee({
+				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 = ue(r), o = ie(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 Oe({
+					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 Ee({
+				kind: o.kind,
+				table: e,
+				operation: t,
+				...o.constraint === void 0 ? {} : { constraint: o.constraint },
+				...o.column === void 0 ? {} : { column: o.column }
+			});
+		}
+	}, ze = (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 = ee.decodeUnknownResult(n)(t);
+		if (r._tag === "Success") return t;
+		let i = te.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
+		});
+	}, Be = () => {
+		let e = { deletedAt: /* @__PURE__ */ new Date() };
+		return A !== null && (e.deletedBy = A), e;
+	}, Ve = (e, t, n) => {
+		let r = _e(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 ? ve(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 = ee.decodeUnknownResult(c)(t);
+		if (l._tag === "Success") return t;
+		let u = te.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 ? Se(t, r, z) : t;
+		return se(i, r, f(), n);
+	}, V = (e, t) => {
+		let n = x(e);
+		return n !== void 0 && le(n).some((e) => t[e] !== void 0 && t[e] !== null);
+	}, He = (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 || le(n).length === 0 ? {
+			descriptor: e,
+			stripId: !1
+		} : {
+			descriptor: {
+				...e,
+				projection: [...t, D]
+			},
+			stripId: !0
+		};
+	}, Ue = process.env.VOLTRO_FIELD_DECRYPT_ON_ERROR === "null" ? "null" : "throw", We = je({ scope: "store.fieldEncryption" }), Ge = /* @__PURE__ */ new Set(), Ke = (e) => {
+		let t = `${e.table}.${e.column}`;
+		Ge.has(t) || (Ge.add(t), We.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"
+		}));
+	}, H = (e, t, n) => {
+		let r = x(e), i = ae(t, r, f(), {
+			onError: Ue,
+			...Ue === "null" ? { warn: Ke } : {},
+			...n === void 0 ? {} : { rowId: n }
+		});
+		return z ? oe(i, r, z) : i;
+	}, qe = (e) => {
+		let t = e.table, n = e.predicate;
+		if (!e.crossTenant && M != null && T.schemaRegistry.hasTenant(t)) {
+			let e = b("tenantId", M);
+			n = n ? y(n, e) : e;
+		}
+		if (!e.includeDeleted && T.schemaRegistry.hasSoftDelete(t)) {
+			let e = S("deletedAt");
+			n = n ? y(n, e) : e;
+		}
+		if (!e.includeExpired && T.schemaRegistry.hasExpires(t)) {
+			let e = ye(S("expiresAt"), pe("expiresAt", /* @__PURE__ */ new Date()));
+			n = n ? y(n, e) : e;
+		}
+		n = c(N, t, n);
+		let r = e.eager === void 0 ? void 0 : Me(t, e.eager, N);
+		return r === void 0 ? n === e.predicate ? e : {
+			...e,
+			predicate: n
+		} : {
+			...e,
+			predicate: n,
+			eager: r
+		};
+	}, Je = async (e) => {
+		let t = He(e), n = await k.query(t.descriptor), r = H(e.table, n);
+		return Ye(e.table, r), t.stripId ? r.map((e) => {
+			let { [D]: t, ...n } = e;
+			return n;
+		}) : r;
+	}, U = async (e) => Je(qe(e)), W = (e, t, n) => {
+		if (he(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.`);
+	}, G = async (e, t) => {
+		if (M === null || !T.schemaRegistry.hasTenant(e)) return;
+		let n = xe(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,
+			predicate: y(n, b("tenantId", M)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: xe(t).map(([e]) => e)
+		})).length > 0)) throw new De({
+			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."
+		});
+	}, K = Symbol.for("@voltro/runtime:tx-fold-releases"), q = Symbol.for("@voltro/runtime:tx-read-versions"), J = (e) => e[q], Y = (e, t) => `${e}\u0000${String(t)}`, Ye = (e, t) => {
+		let n = J(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(Y(e, t), a);
+		}
+	}, X = (() => {
+		let e = globalThis, t = Symbol.for("@voltro/runtime:crdt-fold-locks");
+		return e[t] ??= /* @__PURE__ */ new Map();
+	})(), Xe = async (e, t, n) => {
+		let r = `${e}\u0000${C(t)}`, i = X.get(r) ?? Promise.resolve(), a, o = new Promise((e) => {
+			a = e;
+		});
+		X.set(r, i.then(() => o)), await i;
+		try {
+			return await n();
+		} finally {
+			a(), X.get(r) === o && X.delete(r);
+		}
+	}, Z = 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 et(e, t, i);
+			return o === null || Object.keys(a).length === 0 ? o : Z(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[K];
+			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 Q(e, t, o);
+				await G(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 : H(e, [s[0]])[0];
+			}
+			return Xe(e, t, () => Q(e, t, n));
+		}
+		return Q(e, t, n);
+	}, Q = async (e, t, n) => {
+		W(e, "update", t), await G(e, t);
+		let r = F(e, n), i = T.schemaRegistry.crdtColumns(e);
+		if (o(i, r)) return tt(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 = H(e, [n])[0];
+			r = ze(e, i, r);
+		}
+		r = L(e, r);
+		let a = T.schemaRegistry.versionColumn(e), s;
+		if (a !== void 0) {
+			let n = be({
+				versionColumn: a,
+				patch: r
+			}), i = J(k)?.get(Y(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 = Ce({
+				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, B(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, J(k)?.set(Y(e, C(t)), o + 1);
+					break;
+				}
+				let f = await u();
+				(c !== void 0 || f === null || i >= Ne) && l(new re({
+					table: e,
+					id: C(t),
+					expected: c ?? o,
+					actual: f
+				})), d = f;
+			}
+		} else s = await I(e, "update", r, () => k.update(e, t, B(e, r, t)));
+		return s === null ? null : H(e, [s], t)[0];
+	}, Ze = async (e, t, n) => {
+		let r = await k.query({
+			table: d,
+			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 H(d, r).map((e) => e.state).filter((e) => e instanceof Uint8Array);
+	}, Qe = async (e, t, n, r, i) => {
+		let a = P(d, {
+			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(d, "insert", a, () => k.insert(d, B(d, R(d, a))));
+	}, $e = 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 Ze(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 ke({
+				field: n,
+				message: "crdt.staleLineage",
+				params: { table: e }
+			});
+			return s;
+		}
+		return i;
+	}, et = async (e, t, n) => {
+		await G(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 = H(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, B(e, u, t), { where: y(...c) })) > 0) {
+				for (let n of l) await Qe(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 : H(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)));
+		}
+	}, tt = 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 : be({
+			versionColumn: s,
+			patch: n
+		}), l = s === void 0 ? void 0 : J(k)?.get(Y(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 = H(e, [p])[0], l = f;
+			for (let n of o) {
+				let r = await $e(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 = ze(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 = Ce({
+					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, B(e, v, t), { where: y(...g) })) > 0) {
+				for (let { column: n, archived: r } of m) await Qe(e, t, n, r);
+				let n = await i();
+				return n === void 0 ? null : (s !== void 0 && _ !== void 0 && J(k)?.set(Y(e, C(t)), _ + 1), H(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();
+		}
+	}, nt = async (e, t) => (W(e, "delete", t), await G(e, t), T.schemaRegistry.hasSoftDelete(e) ? await Z(e, t, Be()) !== null : I(e, "delete", void 0, () => k.delete(e, t))), rt = async (e, t, n) => {
+		let r = F(e, t), i = T.schemaRegistry.versionColumn(e);
+		if (i === void 0) {
+			if (!V(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, B(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, B(e, l, r), { where: y(n.where, b(D, r), b(i, o)) }));
+				if (u > 0) {
+					c += u;
+					break;
+				}
+				if (t >= Ne) throw new re({
+					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;
+	}, it = async (e, t) => I(e, "deleteMany", void 0, () => k.deleteMany(e, t)), at = (e, t) => M != null && T.schemaRegistry.hasTenant(e) ? y(t, b("tenantId", M)) : t, ot = async (e, t, n) => rt(e, t, {
+		...n,
+		where: at(e, n.where)
+	}), st = async (e, t) => it(e, {
+		...t,
+		where: at(e, t.where)
+	}), $ = _({
+		query: Je,
+		updateMany: rt,
+		deleteMany: it,
+		delete: (e, t) => k.delete(e, t)
+	}, {
+		subject: T.subject,
+		schemaRegistry: T.schemaRegistry,
+		rowFilter: N
+	}), ct = ((e, t, n) => t === void 0 ? $.updateWhere(e) : Z(e, t, n)), lt = ((e, t) => t === void 0 ? $.deleteWhere(e) : nt(e, t)), ut = async (e, t) => {
+		let n = t.map((t) => P(e, t)), r = x(e), i = t.length >= 32 && r !== void 0 && T.schemaRegistry.insertSchema(e) === void 0 && T.schemaRegistry.crdtColumns(e).size === 0 && T.schemaRegistry.sealedColumns(e).size === 0 ? g(r) : void 0, a = n.map((t) => R(e, t, i)), o = z ? a.map((e) => Se(e, r, z)) : a, s = ce(o, r, f()), c = await I(e, "insertMany", n[0], () => k.insertMany(e, s));
+		return H(e, c);
+	}, dt = (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)
+		};
+	}, ft = (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.`);
+	}, pt = (e, t) => {
+		let { sourceCol: n, sourceId: r, targetCol: i } = dt(e, t), a = async () => (await U({
+			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 ut(e, t.map((e) => ({
+				[n]: r,
+				[i]: e
+			})));
+		}, s = async (t) => {
+			t.length !== 0 && await st(e, { where: y(b(n, r), me(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 U({
+					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 ot(e, c, { where: y(b(n, r), b(i, t)) }));
+				}
+				return f.length > 0 && await ut(e, f), {
+					added: u,
+					removed: l,
+					updated: d
+				};
+			}
+		};
+	}, mt = async (e, t, n, r) => {
+		let i = t[D] !== void 0 && t[D] !== null, a = P(e, t), o = Te(n), s = n;
+		if (Ve(e, a, n.conflictColumns), typeof n.update == "function") {
+			let t = n.update;
+			s = {
+				conflictColumns: n.conflictColumns,
+				update: (n) => {
+					let r = n.id, i = H(e, [n], r)[0], a = F(e, {
+						...t(i),
+						...o
+					});
+					return B(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 = Te({
+				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 = V(e, a) || V(e, o) || r && c === void 0, u = l ? await m(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: H(e, [p], d)[0],
+			outcome: f ?? (c !== void 0 && p[D] !== c ? "updated" : "inserted")
+		};
+	}, ht = async (e, t, n) => {
+		let r = P(e, t);
+		Ve(e, r, n.conflictColumns);
+		let i = await I(e, "insertIgnore", r, () => k.insertIgnoreWithOutcome(e, B(e, R(e, r)), n));
+		return {
+			row: H(e, [i.row])[0],
+			outcome: i.outcome
+		};
+	};
+	return {
+		query: U,
+		one: (async (e, t) => {
+			let n = Pe(e), r = await U({
+				...n,
+				take: 2
+			}), i = r[0];
+			if (i === void 0) throw v({
+				table: n.table,
+				found: 0
+			}, t);
+			if (r.length > 1) throw v({
+				table: n.table,
+				found: r.length
+			}, t);
+			return i;
+		}),
+		first: ((e) => u({ query: U }, e)),
+		maybeOne: ((e) => u({ query: U }, 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 H(e, [r])[0];
+		},
+		insertMany: (async (e, t) => ut(e, t)),
+		links: pt,
+		relationLinks: (e, t, n) => pt(e, { [ft(e, t)]: n }),
+		patchJson: async (e, t, n, r, i) => {
+			W(e, "patchJson", t), await G(e, t);
+			let a = ge(t, n, F(e, ge(t, n, i), [n.split(".")[0]])), o = await I(e, "patchJson", a, () => k.patchJson(e, t, n, r, B(e, L(e, a), t)));
+			return o === null ? null : H(e, [o], t)[0];
+		},
+		select: $.select,
+		update: ct,
+		delete: lt,
+		applyDefined: Fe,
+		hardDelete: async (e, t) => (W(e, "hardDelete", t), await G(e, t), I(e, "hardDelete", void 0, () => k.delete(e, t))),
+		updateMany: ot,
+		deleteMany: st,
+		upsert: async (e, t, n) => (await mt(e, t, n, !1)).row,
+		upsertWithOutcome: (e, t, n) => mt(e, t, n, !0),
+		insertIgnore: async (e, t, n) => (await ht(e, t, n)).row,
+		insertIgnoreWithOutcome: (e, t, n) => ht(e, t, n),
+		transactional: async (e) => {
+			let t = await k.transactional(async (t) => {
+				let n = [];
+				return t[K] = n, t[q] = /* @__PURE__ */ new Map(), {
+					result: await e(Re(t, T)),
+					jobs: n
+				};
+			});
+			for (let e of t.jobs) await Z(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[K] === void 0 ? {} : { [K]: k[K] },
+		...J(k) === void 0 ? {} : { [q]: J(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, Le as actingUserId, Fe as applyDefined, M as isTransactionReadConflict, Re as wrapStoreWithMixinBehaviour };