@voltro/database 0.85.0 → 0.86.0

package/dist/sqliteDecimalSetQuery.js

@@ -0,0 +1,50 @@
+import { sqliteDecimalOutputs as e } from "./sqliteDecimalOutputs.js";
+//#region src/sqliteDecimalSetQuery.ts
+var t = (t, n, r, i) => {
+	let a = (e) => [
+		e.table,
+		...(e.joins ?? []).map((e) => e.table),
+		...e.setOp?.queries.flatMap(a) ?? []
+	], o = "__voltro_decimal_set_";
+	for (; a(t).some((e) => e.toLowerCase().startsWith(o));) o += "_";
+	let s = [], c = (e) => {
+		let t = `${o}${s.length}`;
+		return s.push(n`${n(t)} AS (${e})`), t;
+	}, l = (t) => {
+		if (!t.setOp) throw Error("Missing exact set operation");
+		if (t.ctes || t.distinctOn || t.annClause || t.spatialClause || t.fullTextSearch) throw Error("Unsupported exact set query clause");
+		let a = e(t, r.resultScale);
+		if (new Set(a.map((e) => e.name)).size !== a.length) throw Error("Duplicate exact set output name");
+		let o = {
+			union: "UNION",
+			"union-all": "UNION ALL",
+			intersect: "INTERSECT",
+			except: "EXCEPT"
+		}[t.setOp.kind], s = t.setOp.queries.map((t) => {
+			let o = e(t, r.resultScale), s = a.map((e, t) => {
+				let r = n`${n(o[t].name)}`, i = (e.decimal?.scale ?? 0) - (o[t].decimal?.scale ?? 0), a = i > 0 ? (o[t].decimal.scale === 0 ? "." : "") + "0".repeat(i) : "";
+				return n`${a ? n`${r} || ${a}` : r} AS ${n(`v${t}`)}`;
+			}), u = c(t.setOp ? l(t) : i(t));
+			return n`SELECT ${n.join(", ", !1)(s)} FROM ${n(u)}`;
+		}).reduce((e, t) => n`${e} ${n.unsafe(o)} ${t}`), u = c(s), d = t.order.length ? n` ORDER BY ${n.join(", ", !1)(t.order.flatMap((e) => {
+			let t = a.findIndex((t) => t.name === e.column);
+			if (t < 0) throw Error("Exact set ordering references an unknown output");
+			let r = n`${n(`v${t}`)}`, i = e.direction !== "desc", o = (e, t) => t ? n`${e} ASC` : n`${e} DESC`;
+			if (!a[t].decimal) return [o(r, i)];
+			let s = n`substr(${r}, 1, 1) = '-'`;
+			return [
+				o(n`CASE WHEN ${r} IS NULL THEN NULL WHEN ${s} THEN 0 ELSE 1 END`, i),
+				o(n`CASE WHEN ${s} THEN length(${r}) END`, !i),
+				o(n`CASE WHEN NOT (${s}) THEN length(${r}) END`, i),
+				o(n`CASE WHEN ${s} THEN ${r} END COLLATE BINARY`, !i),
+				o(n`CASE WHEN NOT (${s}) THEN ${r} END COLLATE BINARY`, i)
+			];
+		}))}` : n``;
+		for (let e of [t.take, t.skip]) if (e !== void 0 && (!Number.isSafeInteger(e) || e < 0)) throw Error("Invalid exact set pagination");
+		let f = t.take === void 0 ? t.skip === void 0 ? n`` : n` LIMIT -1` : n` LIMIT ${t.take}`, p = t.skip === void 0 ? n`` : n` OFFSET ${t.skip}`;
+		return n`SELECT ${n.join(", ", !1)(a.map((e, t) => n`${n(`v${t}`)} AS ${n(e.name)}`))} FROM ${n(u)}${d}${f}${p}`;
+	}, u = l(t);
+	return n`WITH ${n.join(", ", !1)(s)} ${u}`;
+};
+//#endregion
+export { t as compileSqliteDecimalSetQuery };

package/dist/sqliteDecimalSource.js

@@ -0,0 +1,63 @@
+import { columnComparisonOperators as e, isColumnReference as t } from "./columnReference.js";
+import { isSqliteDecimalEncodedColumn as n } from "./sqliteDecimalStorage.js";
+import { projectedColumn as r } from "./projectedColumn.js";
+import { compileSqliteDecimalSubquery as i } from "./sqliteDecimalSubquery.js";
+import { compileSqliteDecimalColumnComparison as a, compileSqliteDecimalColumnValue as o } from "./sqliteDecimalColumnSql.js";
+import { lowerSqliteDecimalPredicate as s } from "./sqliteDecimalPredicate.js";
+import { compileStoragePredicate as c } from "./sqlCompiler.js";
+//#region src/sqliteDecimalSource.ts
+var l = (l, u, d, f) => {
+	let p = (f) => {
+		if ("not" in f) return u`NOT (${p(f.not)})`;
+		if ("and" in f) return f.and.length ? u.and(f.and.map(p)) : u`TRUE`;
+		if ("or" in f) return f.or.length ? u.or(f.or.map(p)) : u`FALSE`;
+		if ("subquery" in f) return i(f, u, d, (e) => {
+			let t = r(e, l);
+			if (!t) throw Error("Exact IN subquery requires a declared outer column");
+			let i = u`${u(e)}`;
+			return n(t) ? {
+				value: u.unsafe(o({
+					expression: i.compile()[0],
+					shape: {
+						precision: t.precision,
+						scale: t.scale
+					}
+				})),
+				scale: t.scale
+			} : { value: i };
+		});
+		if (!("value" in f) || !t(f.value)) {
+			if (!("column" in f)) throw Error("Decimal subquery predicates are not integrated yet");
+			let e = r(f.column, l), t = n(e) ? s(f, {
+				precision: e.precision,
+				scale: e.scale
+			}, "column") : f;
+			return c(t, u, null, l.table);
+		}
+		let m = r(f.column, l), h = r(f.value.column, l);
+		if (!m || !h) throw Error("Column comparisons require declared source columns");
+		if (!n(m) && !n(h)) return c(f, u);
+		if (!n(m) || !n(h)) throw Error("Encoded decimal comparisons require two decimal columns");
+		if (!e.includes(f.op) || f.path?.length) throw Error("Unsupported exact decimal column comparison");
+		let g = (e, t) => {
+			if (t.precision === void 0 || t.scale === void 0) throw Error("Decimal comparison requires declared precision and scale");
+			return {
+				expression: u`${u(e)}`.compile()[0],
+				shape: {
+					precision: t.precision,
+					scale: t.scale
+				}
+			};
+		};
+		return u.unsafe(a(g(f.column, m), f.op, g(f.value.column, h)));
+	};
+	return p(f);
+}, u = (e, t, n) => {
+	let r = (r) => l(e, t, n, r), i = n.sourceTable ?? ((e) => e), a = e.alias === void 0 ? t`${t(i(e.table))}` : t`${t(i(e.table))} AS ${t(e.alias)}`;
+	return {
+		from: (e.joins ?? []).reduce((e, n) => t`${e} ${n.kind === "inner" ? t`INNER` : t`LEFT`} JOIN ${t(i(n.table))} AS ${t(n.alias)} ON ${r(n.on)}`, a),
+		where: e.predicate === void 0 ? t`` : t` WHERE ${r(e.predicate)}`
+	};
+};
+//#endregion
+export { u as compileSqliteDecimalSource, l as compileSqliteDecimalSourcePredicate };

package/dist/sqliteDecimalStorage.js

@@ -0,0 +1,29 @@
+import { encodeSqliteDecimal as e } from "./sqliteDecimal.js";
+//#region src/sqliteDecimalStorage.ts
+var t = (e) => e?.type === "decimal" && n(e) !== void 0, n = (t) => {
+	if (t.sqliteDecimalEncoding === void 0) return;
+	if (t.precision === void 0 || t.scale === void 0) throw Error("Encoded SQLite decimal metadata requires precision and scale");
+	let n = {
+		precision: t.precision,
+		scale: t.scale
+	};
+	return e("0", n), n;
+}, r = (t) => (e("0", t), `VOLTRO_DECIMAL_V1_P${t.precision}_S${t.scale}_TEXT`), i = (t) => {
+	let n = /^\s*VOLTRO_DECIMAL_V1_P(\d+)_S(\d+)_TEXT\s*$/i.exec(t);
+	if (!n) return;
+	let r = {
+		precision: Number(n[1]),
+		scale: Number(n[2])
+	};
+	return e("0", r), r;
+}, a = (t, n) => {
+	e("0", n);
+	let r = "D" + "0".repeat(n.precision + 1), i = "D2" + "0".repeat(n.precision);
+	return `(${t} IS NULL OR (typeof(${t}) = 'text' AND length(${t}) = ${n.precision + 2} AND substr(${t}, 1, 1) = 'D' AND substr(${t}, 2) NOT GLOB '*[^0-9]*' AND instr(${t}, char(0)) = 0 AND ${t} COLLATE BINARY > '${r}' AND ${t} COLLATE BINARY < '${i}'))`;
+}, o = (t, n) => {
+	if (t == null) return t;
+	if (typeof t != "string") throw TypeError("SQLite decimal defaults require exact strings");
+	return e(t, n);
+};
+//#endregion
+export { o as encodeSqliteDecimalDefault, t as isSqliteDecimalEncodedColumn, i as parseSqliteDecimalStorageType, a as sqliteDecimalStorageCheck, n as sqliteDecimalStorageShape, r as sqliteDecimalStorageType };

package/dist/sqliteDecimalSubquery.js

@@ -0,0 +1,19 @@
+import { sqliteDecimalOutputs as e } from "./sqliteDecimalOutputs.js";
+//#region src/sqliteDecimalSubquery.ts
+var t = (t, n, r, i) => {
+	let a = r.compile(t.subquery);
+	if (t.op === "exists") return n`EXISTS (${a})`;
+	if (t.op === "not-exists") return n`NOT EXISTS (${a})`;
+	let o = e(t.subquery, r.resultScale);
+	if (o.length !== 1) throw Error("Exact IN subquery must project exactly one column");
+	if (!("column" in t)) throw Error("Unsupported exact subquery predicate");
+	let s = i(t.column), c = o[0];
+	if (s.scale === void 0 != (c.decimal === void 0)) throw Error("Exact IN subquery cannot mix decimal and nondecimal values");
+	let l = Math.max(s.scale ?? 0, c.decimal?.scale ?? 0), u = (e, t) => {
+		let r = l - t;
+		return r ? n`${e} || ${(t === 0 ? "." : "") + "0".repeat(r)}` : e;
+	}, d = u(s.value, s.scale ?? 0), f = n`SELECT ${u(n`${n(c.name)}`, c.decimal?.scale ?? 0)} FROM (${a})`;
+	return t.op === "subquery-in" ? n`${d} IN (${f})` : n`${d} NOT IN (${f})`;
+};
+//#endregion
+export { t as compileSqliteDecimalSubquery };

package/dist/sqliteDecimalWindowQuery.js

@@ -0,0 +1,196 @@
+import { isSqliteDecimalEncodedColumn as e } from "./sqliteDecimalStorage.js";
+import { prepareProjectedColumn as t } from "./projectedColumn.js";
+import { compileSqliteDecimalEncodedSource as n } from "./sqliteDecimalEncodeSql.js";
+import { compileSqliteDecimalDecodedRows as r } from "./sqliteDecimalColumnSql.js";
+import { compileSqliteDecimalResult as i } from "./sqliteDecimalResultSql.js";
+import { compileSqliteDecimalSource as a } from "./sqliteDecimalSource.js";
+import { compileSqliteDecimalAvg as o, compileSqliteDecimalSum as s } from "./sqliteDecimalAggregateSql.js";
+//#region src/sqliteDecimalWindowQuery.ts
+var c = (c, l, u, d, f, p) => {
+	let m = t(c), h = c.aggregations ?? [], g = {
+		"window-row-number": "ROW_NUMBER",
+		"window-rank": "RANK",
+		"window-dense-rank": "DENSE_RANK",
+		"window-lag": "LAG",
+		"window-lead": "LEAD",
+		"window-sum-over": "SUM",
+		"window-avg-over": "AVG"
+	};
+	if (c.groupBy?.length || c.having || c.setOp || c.ctes || c.distinctOn || c.annClause || c.spatialClause || c.fullTextSearch || h.some((e) => e.op !== "column" && !(e.op in g))) throw Error("Exact window queries require supported ungrouped window projections");
+	if (new Set(h.map((e) => e.alias)).size !== h.length) throw Error("Duplicate decimal result alias");
+	let _ = [...new Set(h.flatMap((e) => [
+		...e.column === void 0 ? [] : [e.column],
+		...e.window?.partitionBy ?? [],
+		...(e.window?.orderBy ?? []).map((e) => e.column)
+	]))].map((e, t) => {
+		let n = m(e);
+		if (!n) throw Error("Exact window requires declared source columns");
+		return {
+			source: e,
+			name: `c${t}`,
+			field: n
+		};
+	}), v = new Map(_.map((e) => [e.source, e])), y = (e) => {
+		let t = v.get(e);
+		if (!t) throw Error("Unknown exact window source column");
+		return t.name;
+	}, b = (e) => "\"" + e.replace(/"/g, "\"\"") + "\"", { from: x, where: S } = a(c, l, d), [C, w] = l`SELECT ${l.join(", ", !1)([l`ROW_NUMBER() OVER () AS identity`, ..._.map((e) => l`${l(e.source)} AS ${l(e.name)}`)])} FROM ${x}${S}`.compile(), T = f ?? p, E = T?.prefix ?? "__voltro_decimal_window_", D = [c.table, ...(c.joins ?? []).map((e) => e.table)];
+	for (; D.some((e) => e.toLowerCase().startsWith(E));) E += "_";
+	let O = [], k = (e, t, n) => {
+		T ? T.append(e, t) : O.push(`${e} AS MATERIALIZED (${t})`);
+	};
+	k(E + "source", C, u.materialized);
+	let A = [], j = /* @__PURE__ */ new Map(), M, N = !1, P = (e) => {
+		if (!N) {
+			N = !0;
+			let e = c.order;
+			if (e.length >= 32 && Object.getPrototypeOf(e) === Array.prototype && !Object.hasOwn(e, "some") && !Object.hasOwn(e, Symbol.iterator)) {
+				let t = [];
+				for (let n = 0; n < e.length; n++) {
+					let r = Object.getOwnPropertyDescriptor(e, String(n)), i = r && "value" in r ? Object.getOwnPropertyDescriptor(r.value, "column") : void 0;
+					if (!i || !("value" in i) || typeof i.value != "string") break;
+					t.push(i.value);
+				}
+				t.length === e.length && (M = new Set(t));
+			}
+		}
+		return M?.has(e) ?? c.order.some((t) => t.column === e);
+	};
+	for (let [t, r] of h.entries()) {
+		let a = `SELECT * FROM ${E}source`, c = r.column === void 0 ? void 0 : v.get(r.column);
+		if (r.op === "column") {
+			if (!c) throw Error("Window column projection requires a source column");
+			j.set(r.alias, {
+				value: c.name,
+				key: c.name,
+				encoded: c.field
+			});
+			continue;
+		}
+		let l = [
+			"window-lag",
+			"window-lead",
+			"window-sum-over",
+			"window-avg-over"
+		].includes(r.op);
+		if (l && !c) throw Error("Window operation requires a source column");
+		let d = r.window?.partitionBy?.map(y), p = r.window?.orderBy?.map((e) => ({
+			...e,
+			column: y(e.column)
+		})), m = `w${t}`, h = e(c?.field) && ["window-sum-over", "window-avg-over"].includes(r.op);
+		if (h) {
+			let e = c.field.precision, l = c.field.scale, h = r.op === "window-avg-over" ? u.resultScale ?? l : l, g = e + 20 + Math.max(0, h - l), _ = {
+				kind: "window",
+				identity: "identity",
+				partitionBy: d ?? [],
+				orderBy: p ?? []
+			}, v = /* @__PURE__ */ new Map(), y = 0, x = {
+				prefix: `${E}${t}_`,
+				reference: (e) => {
+					let t = v.get(e);
+					return t === void 0 ? e : `(${t}${t.endsWith("LIMIT -1 OFFSET 0") ? "" : " LIMIT -1 OFFSET 0"}) AS ${e}`;
+				},
+				append: (e, t, n) => {
+					u.materialized || ++y % 4 == 0 ? k(e, t, n) : v.set(e, t);
+				}
+			}, S = {
+				stages: x,
+				sourceSql: `SELECT *,${b(c.name)} AS value FROM (${a})`,
+				precision: e,
+				scope: _,
+				materialized: u.materialized
+			}, C = r.op === "window-avg-over" ? o({
+				...S,
+				inputScale: l,
+				resultScale: h,
+				rounding: u.rounding ?? "half-even"
+			}) : s(S);
+			if (f) {
+				let e = n(`SELECT identity,units AS value FROM (${C})`, {
+					precision: g,
+					scale: 0
+				}, ["identity"], {
+					prefix: x.prefix,
+					reference: x.reference,
+					append: (e, t) => x.append(e, t, u.materialized)
+				});
+				a = `SELECT identity,value AS ${b(m)} FROM ${e}`, j.set(r.alias, {
+					value: m,
+					key: m,
+					encoded: {
+						...c.field,
+						precision: g,
+						scale: h
+					}
+				});
+			} else {
+				let e = i({
+					sourceSql: C,
+					digits: g,
+					scale: h,
+					materialized: u.materialized,
+					stages: x
+				}), t = P(r.alias);
+				a = `SELECT identity,decimal_value AS ${b(m)}${t ? `,decimal_key AS ${b(m + "_key")}` : ""} FROM (${e})`, j.set(r.alias, {
+					value: m,
+					key: t ? m + "_key" : m
+				});
+			}
+		} else {
+			let e = [...d?.length ? [`PARTITION BY ${d.map(b).join(",")}`] : [], ...p?.length ? [`ORDER BY ${p.map((e) => `${b(e.column)} ${e.direction === "desc" ? "DESC" : "ASC"}`).join(",")}`] : []].join(" "), n = r.op === "window-lag" || r.op === "window-lead", i = r.offset ?? 1;
+			if (n && (!Number.isSafeInteger(i) || i < 0)) throw Error("Invalid exact window offset");
+			let o = l ? b(c.name) + (n ? `,${i}` : "") : "";
+			if (r.op === "window-rank" || r.op === "window-dense-rank") {
+				let n = [.../* @__PURE__ */ new Set([...d ?? [], ...(p ?? []).map((e) => e.column)])], i = n.length ? `PARTITION BY ${n.map(b).join(",")}` : "";
+				if (r.op === "window-rank") a = `SELECT *,COUNT(*) OVER (${e})-COUNT(*) OVER (${i})+1 AS ${b(m)} FROM (${a})`;
+				else {
+					let n = `${m}_peer`, r = `${E}peer${t}`;
+					k(r, `SELECT *,CASE WHEN ROW_NUMBER() OVER (${i})=1 THEN 1 ELSE 0 END AS ${b(n)} FROM (${a})`, u.materialized), a = `SELECT *,SUM(${b(n)}) OVER (${e}) AS ${b(m)} FROM ${r}`;
+				}
+			} else if (n) {
+				let e = `${m}_position`, n = `${E}shift${t}`;
+				k(n, `SELECT *,ROW_NUMBER() OVER (${[...d?.length ? [`PARTITION BY ${d.map(b).join(",")}`] : [], `ORDER BY ${[...(p ?? []).map((e) => `${b(e.column)} ${e.direction === "desc" ? "DESC" : "ASC"}`), "identity ASC"].join(",")}`].join(" ")}) AS ${b(e)} FROM (${a})`, u.materialized);
+				let o = [...(d ?? []).map((e) => `shifted.${b(e)} IS current.${b(e)}`), `shifted.${b(e)}=current.${b(e)}${r.op === "window-lag" ? "-" : "+"}${i}`].join(" AND ");
+				a = `SELECT current.*,(SELECT shifted.${b(c.name)} FROM ${n} AS shifted WHERE ${o}) AS ${b(m)} FROM ${n} AS current`;
+			} else a = `SELECT *,${g[r.op]}(${o}) OVER (${e}) AS ${b(m)} FROM (${a}) LIMIT -1 OFFSET 0`;
+			j.set(r.alias, {
+				value: m,
+				key: m,
+				...n ? { encoded: c.field } : {}
+			});
+		}
+		let _ = `${E}stage${t}`, x = h && j.get(r.alias).key !== m ? [m, m + "_key"] : [m];
+		k(_, h ? a : `SELECT identity,${x.map(b).join(",")} FROM (${a})`, u.materialized), A.push({
+			stage: _,
+			values: x
+		});
+	}
+	let F = `${E}output`;
+	k(F, `SELECT ${["input.*", ...A.flatMap((e) => e.values.map((t) => `(SELECT result.${b(t)} FROM ${e.stage} AS result WHERE result.identity=input.identity) AS ${b(t)}`))].join(",")} FROM ${E}source AS input`, u.materialized);
+	let I = new Map([...j.values()].flatMap((t) => e(t.encoded) ? [[t.value, {
+		name: t.value,
+		shape: {
+			precision: t.encoded.precision,
+			scale: t.encoded.scale
+		}
+	}]] : [])), L = r(F, f ? [] : [...I.values()], [
+		"identity",
+		..._.map((e) => e.name),
+		...A.flatMap((e) => e.values)
+	], {
+		prefix: `${E}result_`,
+		append: (e, t) => k(e, t, u.materialized)
+	}), R = h.map((t) => {
+		let n = j.get(t.alias), r = `window_output.${b(n.value)}`;
+		return f && e(n.encoded) ? (f.encodedOutput(t.alias), `${r} AS ${b(t.alias)}`) : `${L.values.get(n.value) ?? (n.encoded?.type === "bigint" ? `CAST(${r} AS TEXT)` : r)} AS ${b(t.alias)}`;
+	}), z = c.order.length ? " ORDER BY " + c.order.map((e) => {
+		let t = j.get(e.column);
+		if (!t) throw Error("Ordering references an unknown window result");
+		return `window_output.${b(t.key)} ${e.direction === "desc" ? "DESC" : "ASC"}`;
+	}).join(",") : "";
+	for (let e of [c.take, c.skip]) if (e !== void 0 && (!Number.isSafeInteger(e) || e < 0)) throw Error("Invalid exact decimal pagination");
+	let B = c.take === void 0 ? c.skip === void 0 ? "" : " LIMIT -1" : ` LIMIT ${c.take}`, V = c.skip === void 0 ? "" : ` OFFSET ${c.skip}`;
+	return l.unsafe(`${T ? "" : `WITH ${O.join(",")} `}SELECT ${c.distinct ? "DISTINCT " : ""}${R.join(",")} FROM ${L.source} AS window_output${z}${B}${V}`, w);
+};
+//#endregion
+export { c as compileSqliteDecimalWindowQuery };

package/dist/sqliteValueCoercion.js

@@ -0,0 +1,4 @@
+//#region src/sqliteValueCoercion.ts
+var e = (t) => t == null ? t : t instanceof Date ? t.toISOString() : typeof t == "boolean" ? +!!t : Array.isArray(t) ? t.map((t) => e(t)) : t;
+//#endregion
+export { e as coerceValueForSqlite };

package/dist/stampId.js

@@ -0,0 +1,21 @@
+import { generateId as e } from "./idGenerator.js";
+import { getTable as t } from "./tableRegistry.js";
+//#region src/stampId.ts
+var n = "id", r = (r, i) => {
+	let a = t(r);
+	if (a === void 0) return i;
+	let o = a.fields[n]?.idScheme;
+	if (o === void 0 || i[n] != null) return i;
+	if (o.kind === "numeric") {
+		if (!(n in i)) return i;
+		let e = { ...i };
+		return delete e[n], e;
+	}
+	let s = e(o, r);
+	return s === null ? i : {
+		...i,
+		[n]: s
+	};
+}, i = (e, t) => t.map((t) => r(e, t));
+//#endregion
+export { r as stampGeneratedId, i as stampGeneratedIds };

package/dist/storeErrors.js

@@ -0,0 +1,9 @@
+//#region src/storeErrors.ts
+var e = (e, t, n) => ({
+	_tag: "PrimaryKeyConflictError",
+	table: e,
+	key: t,
+	cause: n
+}), t = (e) => typeof e == "object" && !!e && e._tag === "PrimaryKeyConflictError";
+//#endregion
+export { t as isPrimaryKeyConflictError, e as primaryKeyConflictError };

package/dist/storeRefusal.js

@@ -0,0 +1,20 @@
+import { authoredError as e, causeBranches as t } from "./dbCause.js";
+//#region src/storeRefusal.ts
+var n = Symbol.for("@voltro/database/storeRefusal"), r = (t) => {
+	let r = e(t.detail);
+	return Object.defineProperty(r, n, {
+		value: t,
+		enumerable: !1
+	}), r;
+}, i = (e) => {
+	for (let r of t(e)) {
+		let e = r;
+		for (let t = 0; e != null && t < 8; t += 1) {
+			let t = e[n];
+			if (t !== void 0) return t;
+			e = e.cause;
+		}
+	}
+};
+//#endregion
+export { r as refuseWrite, i as storeRefusalOf };

package/dist/stream.js

@@ -0,0 +1,36 @@
+import { and as e, gt as t } from "./predicate.js";
+import { Data as n, Effect as r, Option as i, Stream as a } from "effect";
+//#region src/stream.ts
+var o = class extends n.TaggedError("TableStreamError") {}, s = 1e3, c = (n, r, a, o) => {
+	let s = i.match(o, {
+		onNone: () => n.where,
+		onSome: (i) => n.where ? e(n.where, t(r, i)) : t(r, i)
+	});
+	return {
+		table: n.table,
+		predicate: s,
+		order: [{
+			column: r,
+			direction: "asc"
+		}],
+		take: a,
+		skip: void 0,
+		projection: n.projection,
+		...n.includeDeleted === void 0 ? {} : { includeDeleted: n.includeDeleted },
+		...n.crossTenant === void 0 ? {} : { crossTenant: n.crossTenant }
+	};
+}, l = (e, t) => {
+	let n = t.pk ?? "id", l = t.chunkSize ?? s;
+	return a.paginate(i.none(), (a) => {
+		let s = r.tryPromise({
+			try: () => e.query(c(t, n, l, a)),
+			catch: (e) => new o({
+				table: t.table,
+				cause: e
+			})
+		});
+		return (t.retry ? s.pipe(r.retry(t.retry)) : s).pipe(r.map((e) => [e, e.length === l && e.length > 0 ? i.some(i.some(e[e.length - 1][n])) : i.none()]));
+	});
+};
+//#endregion
+export { o as TableStreamError, l as streamTable };

package/dist/subjectGraph.js

@@ -0,0 +1,175 @@
+import { allRegisteredTables as e } from "./tableRegistry.js";
+import { allRegisteredRelations as t } from "./relationsRegistry.js";
+import { types as n } from "node:util";
+//#region src/subjectGraph.ts
+var r = 4, i = (e) => Object.keys(e.fields), a = (e, t) => Object.prototype.hasOwnProperty.call(e.fields, t), o = (e, t) => {
+	let n = [];
+	for (let [r, i] of Object.entries(e.fields)) i.type === "reference" && i.references?.()?.tableName === t && n.push(r);
+	return n;
+}, s = (e, t) => {
+	let n = [];
+	for (let r of t) {
+		if (r.source !== e) continue;
+		let t = r.relation, i;
+		try {
+			i = t.target();
+		} catch {
+			continue;
+		}
+		if (t.kind === "manyToMany") {
+			let e;
+			try {
+				e = t.through();
+			} catch {
+				continue;
+			}
+			if (!a(e, t.sourceKey)) continue;
+			n.push({
+				table: e.tableName,
+				foreignKey: t.sourceKey,
+				parentKey: "id"
+			});
+			continue;
+		}
+		if (t.sourceKey !== void 0) continue;
+		let s = o(i, e), c = t.foreignKey ?? (s.length === 1 ? s[0] : void 0);
+		if (c === void 0 || !a(i, c)) continue;
+		let l = i.fields[c];
+		n.push({
+			table: i.tableName,
+			foreignKey: c,
+			parentKey: l?.referenceColumn ?? "id"
+		});
+	}
+	return n;
+}, c = (e, t) => {
+	let n = [];
+	for (let r of t) if (r.tableName !== e) for (let t of o(r, e)) {
+		let e = r.fields[t];
+		n.push({
+			table: r.tableName,
+			foreignKey: t,
+			parentKey: e?.referenceColumn ?? "id"
+		});
+	}
+	return n;
+}, l = (e) => {
+	if (n.isProxy(e)) return !1;
+	let t = Object.getPrototypeOf(e);
+	return (t === Object.prototype || t === null) && Reflect.ownKeys(e).every((t) => "value" in Object.getOwnPropertyDescriptor(e, t));
+}, u = (e) => !n.isProxy(e) && Object.getPrototypeOf(e) === Array.prototype && Reflect.ownKeys(e).every((t) => typeof t == "string" && (t === "length" || /^(0|[1-9][0-9]*)$/.test(t)) && "value" in Object.getOwnPropertyDescriptor(e, t)), d = (e) => {
+	if (e.length < 32 || !u(e) || !e.every((e) => l(e) && l(e.fields) && Object.values(e.fields).every(l))) return (t) => c(t, e);
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+	e.forEach((e, t) => {
+		n.has(e) || n.set(e, t);
+	});
+	let r, i = !1, a = (e) => {
+		for (let r of e) {
+			let e = n.get(r);
+			for (let [n, i] of Object.entries(r.fields)) {
+				if (i.type !== "reference") continue;
+				let a = i.references?.()?.tableName;
+				if (a === void 0) continue;
+				let o = {
+					order: e,
+					hop: {
+						table: r.tableName,
+						foreignKey: n,
+						parentKey: i.referenceColumn ?? "id"
+					}
+				}, s = t.get(a);
+				s ? s.push(o) : t.set(a, [o]);
+			}
+		}
+	};
+	return (n) => {
+		if (!i) r = e.filter((e) => e.tableName === n), a(e.filter((e) => e.tableName !== n)), i = !0;
+		else if (r?.some((e) => e.tableName !== n)) {
+			a(r), r = void 0;
+			for (let e of t.values()) e.sort((e, t) => e.order - t.order);
+		}
+		return (t.get(n) ?? []).filter((e) => e.hop.table !== n).map((e) => e.hop);
+	};
+}, f = (e) => {
+	if (e.length < 32 || !u(e) || !e.every(l)) return (t) => s(t, e);
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = t.get(n.source);
+		e ? e.push(n) : t.set(n.source, [n]);
+	}
+	return (e) => s(e, t.get(e) ?? []);
+}, p = (e) => `${e.table}\u0000${e.hops.map((e) => `${e.table}.${e.foreignKey}<-${e.parentKey}`).join("|")}`, m = (n) => {
+	let r = n.tables ?? e(), a = n.relations ?? t(), o = n.maxDepth ?? 4, s = new Set(n.exclude ?? []), c = new Map(r.map((e) => [e.tableName, e])), l = [];
+	if (!c.has(n.subjectTable)) return {
+		subjectTable: n.subjectTable,
+		paths: [],
+		limitations: [{
+			kind: "unreachable",
+			table: n.subjectTable,
+			detail: `the subject table '${n.subjectTable}' is not registered — no schema was loaded, or the name is wrong. Registered: ${r.length === 0 ? "<none>" : r.map((e) => e.tableName).join(", ")}`
+		}]
+	};
+	let u = {
+		table: n.subjectTable,
+		hops: [],
+		depth: 0,
+		via: "relation"
+	}, m = d(r), h = f(a), g = [u], _ = /* @__PURE__ */ new Set([p(u)]), v = /* @__PURE__ */ new Set(), y = [u];
+	for (let e = 1; e <= o; e++) {
+		let t = [];
+		for (let n of y) {
+			let r = h(n.table), i = m(n.table), a = [...r.map((e) => [e, "relation"]), ...i.map((e) => [e, "reference"])];
+			for (let [r, i] of a) {
+				if (s.has(r.table)) {
+					l.push({
+						kind: "excluded",
+						table: r.table,
+						detail: `excluded by configuration (reached from '${n.table}')`
+					});
+					continue;
+				}
+				let a = `${r.table}\u0000${r.foreignKey}`;
+				if (v.has(a)) continue;
+				v.add(a);
+				let o = {
+					table: r.table,
+					hops: [...n.hops, r],
+					depth: e,
+					via: i
+				}, c = p(o);
+				_.has(c) || (_.add(c), g.push(o), t.push(o));
+			}
+		}
+		if (t.length === 0) {
+			y = [];
+			break;
+		}
+		y = t;
+	}
+	for (let e of y) (h(e.table).length > 0 || m(e.table).length > 0) && l.push({
+		kind: "depth-truncated",
+		table: e.table,
+		detail: `stopped at maxDepth ${o}; tables linked FROM '${e.table}' were not explored`
+	});
+	let b = new Set(g.map((e) => e.table));
+	for (let e of r) b.has(e.tableName) || s.has(e.tableName) || l.push({
+		kind: "unreachable",
+		table: e.tableName,
+		detail: `no relation() and no reference() column links '${e.tableName}' to '${n.subjectTable}'. If it holds subject data through a plain column, a polymorphic (type,id) pair, JSON or free text, add an explicit subjectScopes entry — this derivation cannot see it. Columns: ${i(e).join(", ")}`
+	});
+	return {
+		subjectTable: n.subjectTable,
+		paths: g,
+		limitations: l
+	};
+}, h = (e) => {
+	let t = [`subject graph · ${e.subjectTable} · ${e.paths.length} table(s) reachable`];
+	for (let n of e.paths) {
+		let r = n.hops.length === 0 ? `${e.subjectTable} (the subject row itself)` : [e.subjectTable, ...n.hops.map((e) => `${e.table}.${e.foreignKey}`)].join(" → ");
+		t.push(`  • ${n.table}  [depth ${n.depth}, via ${n.via}]`), t.push(`      ${r}`);
+	}
+	let n = e.limitations.filter((e) => e.kind === "depth-truncated"), r = e.limitations.filter((e) => e.kind === "unreachable"), i = e.limitations.filter((e) => e.kind === "excluded");
+	return t.push(""), t.push("  WHAT THIS CANNOT SEE — a DSAR is only as complete as this list is short:"), n.length > 0 && t.push(`    depth-truncated (${n.length}): ${n.map((e) => e.table).join(", ")}`), i.length > 0 && t.push(`    excluded (${i.length}): ${[...new Set(i.map((e) => e.table))].join(", ")}`), t.push(r.length === 0 ? "    unreachable: none — every registered table is linked to the subject." : `    unreachable (${r.length}): ${r.map((e) => e.table).join(", ")}`), t.push("    Always outside this graph: object storage / uploaded files, external processors,"), t.push("    log and metric sinks, backups, and any subject id embedded in JSON or free text."), t.join("\n");
+};
+//#endregion
+export { r as DEFAULT_SUBJECT_GRAPH_DEPTH, m as deriveSubjectGraph, h as formatSubjectGraph };