@voltro/database 0.85.0 → 0.86.0

package/dist/table.js

@@ -0,0 +1,394 @@
+import { SELF_REFERENCE_TARGET as e, materializeFields as t } from "./columns.js";
+import { pluginRefSpecOf as n } from "./pluginRef.js";
+import { validateColumnName as r, validateIndexName as i, validateTableName as a } from "./identifierLimits.js";
+import { resolveIdScheme as o } from "./idGenerator.js";
+import { resolveMixinGraph as s } from "./mixins.js";
+import { resolveGinOpclass as c } from "./ginIndex.js";
+import { Schema as l, Struct as u } from "effect";
+//#region src/table.ts
+var d = (e, ...t) => {
+	if (t.length === 0) throw Error(`jsonIndex("${e}"): at least one path segment is required`);
+	let n = (r) => ({
+		jsonPath: {
+			column: e,
+			path: t,
+			numeric: r
+		},
+		numeric: () => n(!0)
+	});
+	return n(!1);
+}, f = (e = "cosine", t = "float32") => {
+	let n = t === "half" ? "halfvec" : "vector";
+	switch (e) {
+		case "cosine": return `${n}_cosine_ops`;
+		case "l2": return `${n}_l2_ops`;
+		case "inner": return `${n}_ip_ops`;
+	}
+}, p = [
+	"id",
+	"tenantId",
+	"createdAt",
+	"updatedAt",
+	"createdBy",
+	"updatedBy",
+	"deletedAt",
+	"deletedBy"
+], m = (e) => e.id ?? `<anonymous mixin: ${Object.keys(e.fields).join(", ")}>`, h = (e, t) => `${e}_${t.join("_")}_idx`, g = (e, t) => `${e}_${t.join("_")}_uq`, _ = (e, t, n, r, i, a) => {
+	if (a?.gin !== void 0) {
+		if (n !== "gin") throw Error("GIN opclass requires kind: gin");
+		if (c(a), r.length !== 1 || typeof r[0] != "string") throw Error(`GIN opclass index '${t}' must reference exactly one plain column`);
+	}
+	if (n !== "hnsw") return;
+	if (r.length !== 1) throw Error(`hnsw index '${t}' on table '${e}' must cover exactly one vector column — got ${r.length} fields. pgvector's HNSW access method indexes a single vector column.`);
+	let o = r[0];
+	if (typeof o != "string") throw Error(`hnsw index '${t}' on table '${e}' must reference a vector COLUMN, not an expression. pgvector's HNSW access method indexes a column directly.`);
+	let s = i[o];
+	if (s === void 0) throw Error(`hnsw index '${t}' on table '${e}' references unknown column '${o}'.`);
+	if (s.type !== "vector") throw Error(`hnsw index '${t}' on table '${e}' requires a vector() column — column '${o}' is '${s.type}'. HNSW is the pgvector approximate-nearest-neighbour method and only applies to vectors.`);
+}, v = (e, t) => {
+	let n;
+	for (let [r, i] of Object.entries(e)) i.type === "id" && i.idScheme === void 0 && (n === void 0 && (n = { ...e }), n[r] = {
+		...i,
+		idScheme: o(i.idSchemeInput, t)
+	});
+	return n ?? e;
+}, y = (e, t) => {
+	let n = (e) => Object.getPrototypeOf(e) === Object.prototype && Object.values(Object.getOwnPropertyDescriptors(e)).every((e) => "value" in e), r = (e) => {
+		if (Object.getPrototypeOf(e) !== Array.prototype || Object.hasOwn(e, Symbol.iterator)) return !1;
+		for (let t = 0; t < e.length; t++) {
+			let n = Object.getOwnPropertyDescriptor(e, String(t));
+			if (!n || !("value" in n) || typeof n.value != "string") return !1;
+		}
+		return !0;
+	}, i = 0, a = t.every((e) => {
+		let t = Object.getOwnPropertyDescriptor(e, "indexes");
+		if (t === void 0) return Object.getPrototypeOf(e) === Object.prototype;
+		if (!("value" in t)) return !1;
+		let n = t.value;
+		return n === void 0 ? !0 : Object.getPrototypeOf(n) !== Array.prototype || Object.hasOwn(n, Symbol.iterator) ? !1 : (i += n.length, !0);
+	});
+	if (!(i < 32 || !a)) {
+		for (let e of t) {
+			let t = e.indexes ?? [];
+			for (let e = 0; e < t.length; e++) {
+				let i = Object.getOwnPropertyDescriptor(t, String(e));
+				if (!i || !("value" in i) || !n(i.value) || !r(i.value.fields)) return;
+			}
+		}
+		return e.every(n) ? new Set(e.map((e) => e.name)) : void 0;
+	}
+}, b = (e) => {
+	let t = e.appliedPrimaryKey ?? [], o = Object.entries(e.fields).flatMap(([t, r]) => {
+		let i = n(r);
+		if (i === void 0) return [];
+		if (i.orphanPolicy === "null" && r.nullable !== !0) throw Error(`pluginRef: ${e.tableName}.${t} orphanPolicy: 'null' requires .nullable().`);
+		return [{
+			column: t,
+			...i
+		}];
+	});
+	return {
+		tableName: e.tableName,
+		fields: e.fields,
+		isReactive: e.isReactive,
+		appliedMixins: e.appliedMixins,
+		appliedIndexes: e.appliedIndexes,
+		appliedUniques: e.appliedUniques,
+		appliedFullText: e.appliedFullText,
+		appliedChecks: e.appliedChecks,
+		appliedRules: e.appliedRules ?? [],
+		appliedPluginRefs: o,
+		appliedPrimaryKey: t,
+		...e.previousTableName === void 0 ? {} : { previousTableName: e.previousTableName },
+		...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+		...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema },
+		fullTextIndex: ((t, n, r) => {
+			if (n.length === 0) throw Error(`fullTextIndex '${t}' on '${e.tableName}' has no columns.`);
+			if (i(e.tableName, t, !1, n), e.appliedFullText.some((e) => e.name === t)) throw Error(`duplicate full-text index '${t}' on table '${e.tableName}'.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: e.appliedIndexes,
+				appliedUniques: e.appliedUniques,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				appliedFullText: [...e.appliedFullText, {
+					name: t,
+					columns: [...n],
+					...r?.config === void 0 ? {} : { config: r.config },
+					...r?.weights === void 0 ? {} : { weights: r.weights }
+				}],
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		with: ((...t) => {
+			let n = s(t), a = { ...e.fields }, o = /* @__PURE__ */ new Map();
+			for (let e of Object.keys(a)) o.set(e, {
+				id: "<table>",
+				fields: {}
+			});
+			for (let t of n) for (let [n, i] of Object.entries(t.fields)) {
+				let s = o.get(n);
+				if (s !== void 0) throw Error(`mixin collision on column '${n}' in table '${e.tableName}': '${m(s)}' and '${m(t)}' both define it. If they're the same mixin reached via different paths, set a shared 'id' on both. If they're genuinely different concerns, rename one of the columns.`);
+				r(e.tableName, n), a[n] = i, o.set(n, t);
+			}
+			let c = [...e.appliedIndexes], l = y(c, n);
+			for (let t of n) for (let n of t.indexes ?? []) {
+				let t = n.name ?? h(e.tableName, n.fields);
+				(l?.has(t) ?? c.some((e) => e.name === t)) || (i(e.tableName, t, n.name === void 0, n.fields), _(e.tableName, t, n.kind, n.fields, a, n.kindOptions), c.push({
+					name: t,
+					fields: n.fields,
+					...n.kind === void 0 ? {} : { kind: n.kind },
+					...n.kindOptions === void 0 ? {} : { kindOptions: n.kindOptions }
+				}), l?.add(t));
+			}
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: a,
+				isReactive: e.isReactive,
+				appliedMixins: [...e.appliedMixins, ...n],
+				appliedIndexes: c,
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		index: ((...t) => {
+			let n, r, a, o = Array.isArray(t[0]);
+			if (o ? (r = t[0], a = t[1], n = h(e.tableName, r)) : (n = t[0], r = t[1], a = t[2]), r.length === 0) throw Error(`index '${n}' on table '${e.tableName}' has no fields — an index must cover at least one column.`);
+			let s = r.filter((e) => typeof e == "string");
+			if (i(e.tableName, n, o, s), _(e.tableName, n, a?.kind, r, e.fields, a?.kindOptions), e.appliedIndexes.some((e) => e.name === n)) throw t.length === 1 ? Error(`duplicate auto-named index '${n}' on table '${e.tableName}' — you've called .index(${JSON.stringify(r)}) twice. Pass an explicit name to the second one if both are intended (rare).`) : Error(`duplicate index '${n}' on table '${e.tableName}': each index name must be unique within a table.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: [...e.appliedIndexes, {
+					name: n,
+					fields: [...r],
+					...a?.where === void 0 ? {} : { where: a.where },
+					...a?.kind === void 0 ? {} : { kind: a.kind },
+					...a?.kindOptions === void 0 ? {} : { kindOptions: a.kindOptions }
+				}],
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		expressionIndex: ((t, n, r) => {
+			if (n.length === 0) throw Error(`expressionIndex '${t}' on table '${e.tableName}' has no fields — an index must cover at least one column or expression.`);
+			let a = n.filter((e) => typeof e == "string");
+			if (i(e.tableName, t, !1, a), _(e.tableName, t, r?.kind, n, e.fields, r?.kindOptions), e.appliedIndexes.some((e) => e.name === t)) throw Error(`duplicate index '${t}' on table '${e.tableName}': each index name must be unique within a table.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: [...e.appliedIndexes, {
+					name: t,
+					fields: [...n],
+					...r?.where === void 0 ? {} : { where: r.where },
+					...r?.kind === void 0 ? {} : { kind: r.kind },
+					...r?.kindOptions === void 0 ? {} : { kindOptions: r.kindOptions }
+				}],
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		unique: ((...t) => {
+			let n, r, a, o = Array.isArray(t[0]);
+			if (o ? (r = t[0], a = t[1], n = g(e.tableName, r)) : (n = t[0], r = t[1], a = t[2]), r.length === 0) throw Error(`unique '${n}' on table '${e.tableName}' has no fields — a UNIQUE constraint must cover at least one column.`);
+			if (i(e.tableName, n, o, r), e.appliedUniques.some((e) => e.name === n)) throw Error(o ? `duplicate auto-named UNIQUE '${n}' on table '${e.tableName}' — you've called .unique(${JSON.stringify(r)}) twice. Pass an explicit name to the second one if both are intended (very rare).` : `duplicate UNIQUE '${n}' on table '${e.tableName}': each constraint name must be unique within a table.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: e.appliedIndexes,
+				appliedUniques: [...e.appliedUniques, {
+					name: n,
+					fields: [...r],
+					...a?.dedup === void 0 ? {} : { dedup: a.dedup }
+				}],
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		uniqueActive: ((...t) => {
+			let n, r, a, o = Array.isArray(t[0]);
+			if (o ? (r = t[0], a = t[1], n = h(e.tableName, r)) : (n = t[0], r = t[1], a = t[2]), r.length === 0) throw Error(`uniqueActive '${n}' on table '${e.tableName}' has no fields — a partial UNIQUE must cover at least one column.`);
+			if (i(e.tableName, n, o, r), e.appliedIndexes.some((e) => e.name === n)) throw Error(`duplicate index '${n}' on table '${e.tableName}': each index name must be unique within a table (uniqueActive shares the index namespace).`);
+			let s = a?.where ?? "\"deletedAt\" IS NULL";
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: [...e.appliedIndexes, {
+					name: n,
+					fields: [...r],
+					where: s,
+					unique: !0
+				}],
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		check: ((t, n) => {
+			if (n.trim().length === 0) throw Error(`CHECK '${t}' on table '${e.tableName}' has an empty expression.`);
+			if (i(e.tableName, t, !1, []), e.appliedChecks.some((e) => e.name === t)) throw Error(`duplicate CHECK '${t}' on table '${e.tableName}': each constraint name must be unique within a table.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: e.appliedIndexes,
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: [...e.appliedChecks, {
+					name: t,
+					expr: n
+				}],
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		rule: ((t, n, r) => {
+			if (t.trim().length === 0) throw Error(`rule on table '${e.tableName}' has an empty name.`);
+			let i = e.appliedRules ?? [];
+			if (i.some((e) => e.name === t)) throw Error(`duplicate rule '${t}' on table '${e.tableName}': each rule name must be unique within a table.`);
+			return b({
+				...e,
+				appliedRules: [...i, {
+					name: t,
+					predicate: n,
+					severity: r?.severity ?? "error"
+				}]
+			});
+		}),
+		renamedFrom: ((t) => {
+			if (t === e.tableName) throw Error(`renamedFrom('${t}') on table '${e.tableName}' names the table itself — drop the marker, there is nothing to rename.`);
+			return a(t), b({
+				...e,
+				previousTableName: t
+			});
+		}),
+		primaryKey: ((n) => {
+			if (n.length === 0) throw Error(`primaryKey([...]) on table '${e.tableName}' needs at least one column.`);
+			let r = /* @__PURE__ */ new Set();
+			for (let t of n) {
+				if (!(t in e.fields)) throw Error(`primaryKey([...]) on table '${e.tableName}' references unknown column '${t}'.`);
+				if (r.has(t)) throw Error(`primaryKey([...]) on table '${e.tableName}' lists column '${t}' twice.`);
+				r.add(t);
+			}
+			if (t.length > 0) throw Error(`primaryKey([...]) declared twice on table '${e.tableName}'.`);
+			for (let [t, r] of Object.entries(e.fields)) if (r.type === "id" && !n.includes(t)) throw Error(`primaryKey([...]) on table '${e.tableName}' conflicts with the id() column '${t}'. The explicit primary key IS the key — drop the id() column, or include '${t}' in the composite key.`);
+			return b({
+				...e,
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: e.appliedIndexes,
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: [...n],
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
+		nonReactive: (() => b({
+			...e,
+			tableName: e.tableName,
+			fields: e.fields,
+			isReactive: !1,
+			appliedMixins: e.appliedMixins,
+			appliedIndexes: e.appliedIndexes,
+			appliedUniques: e.appliedUniques,
+			appliedFullText: e.appliedFullText,
+			appliedChecks: e.appliedChecks,
+			appliedPrimaryKey: e.appliedPrimaryKey,
+			...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+			...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+		})),
+		validate: ((t) => b({
+			...e,
+			tableName: e.tableName,
+			fields: e.fields,
+			isReactive: e.isReactive,
+			appliedMixins: e.appliedMixins,
+			appliedIndexes: e.appliedIndexes,
+			appliedUniques: e.appliedUniques,
+			appliedFullText: e.appliedFullText,
+			appliedChecks: e.appliedChecks,
+			appliedPrimaryKey: e.appliedPrimaryKey,
+			insertSchema: t,
+			...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+		})),
+		validatePatch: ((t) => b({
+			...e,
+			tableName: e.tableName,
+			fields: e.fields,
+			isReactive: e.isReactive,
+			appliedMixins: e.appliedMixins,
+			appliedIndexes: e.appliedIndexes,
+			appliedUniques: e.appliedUniques,
+			appliedFullText: e.appliedFullText,
+			appliedChecks: e.appliedChecks,
+			appliedPrimaryKey: e.appliedPrimaryKey,
+			...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+			validatePatchSchema: t.mapFields(u.map(l.optional))
+		}))
+	};
+}, x = (n, i) => {
+	a(n);
+	let o = v(t(i), n);
+	for (let e of Object.keys(o)) r(n, e);
+	let s;
+	for (let [t, r] of Object.entries(o)) r.references === e && (r.references = () => {
+		if (s === void 0) throw Error(`selfReference() on '${n}.${t}' read before table() returned`);
+		return s;
+	});
+	return s = b({
+		tableName: n,
+		fields: o,
+		isReactive: !0,
+		appliedMixins: [],
+		appliedIndexes: [],
+		appliedUniques: [],
+		appliedFullText: [],
+		appliedChecks: [],
+		appliedRules: []
+	}), s;
+};
+//#endregion
+export { p as AUTO_FILLED_COLUMNS, d as jsonIndex, x as table, f as vectorDistanceToOpclass };

package/dist/tableRegistry.js

@@ -0,0 +1,16 @@
+//#region src/tableRegistry.ts
+var e = Symbol.for("@voltro/database/tableRegistry"), t = globalThis, n = t[e] ?? (t[e] = /* @__PURE__ */ new Map()), r = (e) => {
+	let t = n.get(e.tableName);
+	if (t === void 0) n.set(e.tableName, e);
+	else if (t !== e) throw Error(`duplicate table '${e.tableName}' registration: two different table descriptors claim the same name. Rename one or import the shared module that defines it.`);
+}, i = (e) => {
+	n.get(e.tableName) === void 0 && n.set(e.tableName, e);
+}, a = (e) => n.get(e), o = (e) => {
+	let t = n.get(e);
+	if (t === void 0) throw Error(`table '${e}' is not registered. Register it by wrapping it in \`databaseHandle({ ... })\` (the usual path) or call \`registerTable(t)\` explicitly before this runs. Note a \`queryFor(t)\` query carries its own source table, so eager-loads don't hit this — this error means a reconstructed descriptor or by-name tooling reached an unregistered table.`);
+	return t;
+}, s = () => [...n.values()], c = (e) => n.delete(e), l = () => {
+	n.clear();
+}, u = (e) => n.get(e)?.isReactive !== !1;
+//#endregion
+export { s as allRegisteredTables, l as clearTableRegistry, i as ensureTableRegistered, a as getTable, u as isTableReactive, r as registerTable, o as requireTable, c as unregisterTable };

package/dist/tenantSelection.js

@@ -0,0 +1,27 @@
+import { eq as e } from "./predicate.js";
+import { _voltroTenantSelectionsTable as t } from "./frameworkTables.js";
+import { createHash as n } from "node:crypto";
+//#region src/tenantSelection.ts
+var r = t.tableName, i = (e) => n("sha256").update(`${e.type}\u0000${e.id}`, "utf8").digest("hex"), a = async (t, n) => {
+	let [a] = await t.query({
+		table: r,
+		predicate: e("id", i(n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), o = a?.tenantId;
+	return typeof o == "string" ? o : null;
+}, o = async (e, t, n) => {
+	await e.upsert(r, {
+		id: i(t),
+		subjectType: t.type,
+		subjectId: t.id,
+		tenantId: n,
+		selectedAt: /* @__PURE__ */ new Date()
+	}, { conflictColumns: ["id"] });
+}, s = async (e, t) => {
+	await e.delete(r, i(t));
+};
+//#endregion
+export { r as TENANT_SELECTIONS_TABLE, s as deleteTenantSelection, a as readTenantSelection, i as tenantSelectionId, o as writeTenantSelection };

package/dist/transactionOutcome.js

@@ -0,0 +1,97 @@
+import { causeBranches as e } from "./dbCause.js";
+import { currentWriteAttribution as t, runWithWriteAttribution as n } from "./writeAttribution.js";
+import { observeDbOp as r } from "./dbMetrics.js";
+import { Cause as i, Effect as a, Exit as o, Option as s, Schedule as c } from "effect";
+import { SqlClient as l } from "effect/sql";
+//#region src/transactionOutcome.ts
+var u = (e) => {
+	if (o.isSuccess(e)) return e.value;
+	let t = i.squash(e.cause);
+	throw e.cause.reasons.length > 1 && typeof t == "object" && t && Object.isExtensible(t) && Object.defineProperty(t, "voltroCause", {
+		value: e.cause,
+		enumerable: !1,
+		configurable: !0
+	}), t;
+}, d = "10 millis", f = 3, p = (e) => c.max([c.exponential(d), c.recurs(f)]).pipe(c.while(({ input: t }) => e(t))), m = l.TransactionConnection(0), h = /* @__PURE__ */ new WeakMap(), g = (e, t, n) => {
+	let r = h.get(n);
+	return r === void 0 ? a.provideService(e, t, n) : a.provideContext(e, r);
+}, _ = async (e) => {
+	let t = 0, n = a.suspend(() => {
+		let n = ++t;
+		return e.withTransaction(a.flatMap(a.serviceOption(e.transactionService), (t) => {
+			if (s.isNone(t)) return a.fail(/* @__PURE__ */ Error(`${e.label}: TransactionConnection unexpectedly missing inside withTransaction.`));
+			let r = t.value, i = a.tryPromise({
+				try: () => e.body(r, n),
+				catch: (e) => e
+			});
+			return a.flatMap(a.context(), (t) => (h.set(r, t), e.prepare === void 0 ? i : a.flatMap(e.prepare(r), () => i)));
+		})).pipe(a.catchDefect((t) => e.isRetryable(t) ? a.fail(t) : a.die(t)));
+	}).pipe(a.retry(p(e.isRetryable)), a.withSpan(e.span.name, { attributes: { ...e.span.attributes } }));
+	return r(e.dialect, "transaction", async () => u(await e.runPromiseExit(e.wrapProgram === void 0 ? n : e.wrapProgram(n))));
+}, v = class extends Error {
+	swallowed;
+	_tag = "TransactionAborted";
+	constructor(e, t) {
+		super(`${e}: a statement failed inside this transaction and the error was caught, but the database had already aborted the transaction — every later statement was refused, and COMMIT would have rolled back ALL of its writes, including the ones that succeeded. Nothing was committed.
+  the caught failure: ${S(t)}\n  to tolerate a failing statement and keep the rest, run it inside \`tx.savepoint(() => …)\` — only that statement is rolled back. To keep all-or-nothing, let the error propagate.`, { cause: t }), this.swallowed = t, this.name = "TransactionAbortedError";
+	}
+}, y = (e, t = "transactional()") => {
+	let n = 0, r, i = (e) => {
+		r === void 0 && (r = { error: e });
+	};
+	return {
+		track: (a) => r === void 0 ? n > 0 ? a() : a().catch((t) => {
+			throw e(t) && i(t), t;
+		}) : Promise.reject(new v(t, r.error)),
+		inSavepoint: async (e) => {
+			n++;
+			try {
+				return await e();
+			} finally {
+				n--;
+			}
+		},
+		record: i,
+		abortedBy: () => r
+	};
+}, b = async (e, t) => {
+	let { tracker: n, name: r, exec: i, spelling: a } = e;
+	await n.track(() => i(a === "mssql" ? `SAVE TRANSACTION ${r}` : `SAVEPOINT ${r}`));
+	try {
+		let e = await n.inSavepoint(t);
+		return a === "standard" && await n.track(() => i(`RELEASE SAVEPOINT ${r}`)), e;
+	} catch (e) {
+		throw await i(a === "mssql" ? `ROLLBACK TRANSACTION ${r}` : `ROLLBACK TO SAVEPOINT ${r}`).catch((e) => n.record(e)), a === "standard" && await i(`RELEASE SAVEPOINT ${r}`).catch(() => void 0), e;
+	}
+}, x = (e) => e instanceof v || typeof e == "object" && !!e && e._tag === "TransactionAborted", S = (t) => {
+	for (let n of e(t)) {
+		let e = n;
+		for (let t = 0; t < 5 && typeof e == "object" && e; t++) {
+			let t = e.code, n = e.message;
+			if (typeof t == "string" && typeof n == "string") return `${n} (${t})`;
+			e = e.cause;
+		}
+	}
+	return t instanceof Error ? t.message : String(t);
+}, C = async (e) => {
+	let r = t(), i = r === void 0 ? (e) => e() : (e) => n(r, e), a = await _({
+		...e,
+		body: (t) => {
+			let n = e.makeView(t, r);
+			return i(() => e.work(n)).then((t) => {
+				let r = n.abortedBy?.();
+				if (r !== void 0) throw e.isRetryable(r.error) ? r.error : new v(e.label, r.error);
+				return {
+					result: t,
+					view: n
+				};
+			}, (t) => {
+				let r = n.abortedBy?.();
+				throw r !== void 0 && e.isRetryable(r.error) ? r.error : t;
+			});
+		}
+	});
+	return a.view.commitEvents(), a.result;
+};
+//#endregion
+export { m as SHARED_TRANSACTION_SERVICE, v as TransactionAbortedError, x as isTransactionAbortedError, y as makeTransactionAbortTracker, g as onTransaction, _ as runRetryingTransaction, b as runSavepoint, C as runStoreTransaction, u as settleTransactionExit, p as transactionRetrySchedule };

package/dist/transientContention.js

@@ -0,0 +1,36 @@
+import { causeBranches as e } from "./dbCause.js";
+//#region src/transientContention.ts
+var t = /* @__PURE__ */ new Set([
+	"1213",
+	"ER_LOCK_DEADLOCK",
+	"1205",
+	"ER_LOCK_WAIT_TIMEOUT",
+	"1020",
+	"ER_CHECKREAD"
+]), n = /* @__PURE__ */ new Set(["40001", "40P01"]), r = /* @__PURE__ */ new Set(["1205"]), i = /* @__PURE__ */ new Set([
+	"SQLITE_BUSY",
+	"5",
+	"SQLITE_BUSY_SNAPSHOT",
+	"517",
+	"SQLITE_LOCKED",
+	"6"
+]), a = /write-write conflict|write-read conflict|database is locked|table is locked|database is busy/i, o = /* @__PURE__ */ new Set([
+	1213,
+	1205,
+	1020
+]), s = /* @__PURE__ */ new Set([
+	...t,
+	...n,
+	...r,
+	...i
+]), c = (t) => e(t).some(l), l = (e) => {
+	let t = e;
+	for (let e = 0; e < 6 && typeof t == "object" && t; e++) {
+		let e = t;
+		if (typeof e.errno == "number" && o.has(e.errno) || typeof e.number == "number" && r.has(String(e.number)) || typeof e.code == "string" && s.has(e.code) || typeof e.sqlState == "string" && n.has(e.sqlState) || typeof e.message == "string" && a.test(e.message)) return !0;
+		t = e.cause;
+	}
+	return !1;
+};
+//#endregion
+export { r as MSSQL_TRANSIENT_NUMBERS, t as MYSQL_TRANSIENT_CODES, n as POSTGRES_TRANSIENT_STATES, i as SQLITE_TRANSIENT_CODES, a as TURSO_TRANSIENT_MESSAGE, c as isTransientContention };

package/dist/typedStore.js

@@ -0,0 +1,16 @@
+import { authoredError as e } from "./dbCause.js";
+//#region src/typedStore.ts
+var t = (e, t, n) => e.insert(t.tableName, n), n = (e, t, n) => e.insertMany(t.tableName, n), r = (e, t, n, r) => e.upsert(t.tableName, n, {
+	conflictColumns: r.conflictColumns,
+	...r.update === void 0 ? {} : { update: r.update },
+	...r.updateValues === void 0 ? {} : { updateValues: r.updateValues }
+}), i = async (t, n, r, i) => {
+	if (t.upsertWithOutcome === void 0) throw e("upsertRowOutcome: this store does not implement `upsertWithOutcome`. It is provided by the framework's store wrapper, so `ctx.store` has it; a hand-written DataStore must add it.");
+	return t.upsertWithOutcome(n.tableName, r, {
+		conflictColumns: i.conflictColumns,
+		...i.update === void 0 ? {} : { update: i.update },
+		...i.updateValues === void 0 ? {} : { updateValues: i.updateValues }
+	});
+}, a = async (e, t, n, r) => e.insertIgnoreWithOutcome(t.tableName, n, { conflictColumns: r.conflictColumns }), o = (e, t, n, r) => e.updateMany(t.tableName, n, { where: r.where });
+//#endregion
+export { a as insertIgnoreRowOutcome, n as insertManyRows, t as insertRow, o as updateManyRow, r as upsertRow, i as upsertRowOutcome };

package/dist/upsertUpdate.js

@@ -0,0 +1,20 @@
+import { authoredError as e } from "./dbCause.js";
+//#region src/upsertUpdate.ts
+var t = (t) => Object.fromEntries(Object.entries(t.updateValues ?? {}).filter(([n, r]) => {
+	if (r === void 0) return !1;
+	if (n === "id" || t.conflictColumns.includes(n)) throw e(`upsert: updateValues cannot rewrite row identity column '${n}'`);
+	return !0;
+})), n = (e, n, r) => {
+	let i = t(r);
+	if (typeof r.update == "function") return {
+		...r.update(n),
+		...i
+	};
+	let a = r.update ?? Object.keys(e).filter((e) => e !== "id" && !r.conflictColumns.includes(e));
+	return {
+		...Object.fromEntries(a.filter((t) => t in e).map((t) => [t, e[t]])),
+		...i
+	};
+};
+//#endregion
+export { n as upsertUpdatePatch, t as upsertUpdateValues };

package/dist/vectorEmbedding.js

@@ -0,0 +1,31 @@
+import { vector as e } from "./columns.js";
+import { defineMixin as t } from "./mixins.js";
+//#region src/vectorEmbedding.ts
+var n = async (e, t) => {
+	let n = e.as ?? "embedding", r = t.row[e.from];
+	if (typeof r != "string" || r.length === 0) return {};
+	let i = await t.embed(r);
+	return { [n]: i };
+}, r = (r) => {
+	if (!Number.isInteger(r.dimensions) || r.dimensions <= 0) throw Error(`vectorEmbedding: dimensions must be a positive integer, got ${String(r.dimensions)}.`);
+	let i = r.as ?? "embedding", a = (e) => n(r, e);
+	return t({
+		id: "voltro/vectorEmbedding",
+		fields: { [i]: e(r.dimensions) },
+		...r.index === !1 ? {} : { indexes: [{
+			fields: [i],
+			kind: "hnsw",
+			kindOptions: { hnsw: {
+				...r.index?.m === void 0 ? {} : { m: r.index.m },
+				...r.index?.efConstruction === void 0 ? {} : { efConstruction: r.index.efConstruction },
+				distance: r.distance ?? "cosine"
+			} }
+		}] },
+		behaviors: {
+			beforeInsert: a,
+			beforeUpdate: a
+		}
+	});
+};
+//#endregion
+export { n as computeEmbedding, r as vectorEmbedding };