@voltro/runtime 0.84.0 → 0.86.0

package/dist/insertRequiredColumns.js

@@ -0,0 +1,19 @@
+import { types as e } from "node:util";
+//#region src/insertRequiredColumns.ts
+var t = (t) => {
+	if (e.isProxy(t)) return !1;
+	let n = Object.getPrototypeOf(t);
+	return (n === Object.prototype || n === null) && Reflect.ownKeys(t).every((e) => "value" in Object.getOwnPropertyDescriptor(t, e));
+}, n = (e) => {
+	if (!t(e)) return;
+	let n = e.fields;
+	if (!t(n)) return;
+	let r = [];
+	for (let [e, i] of Object.entries(n)) {
+		if (!t(i)) return;
+		!i.nullable && !i.hasDefault && i.idScheme === void 0 && i.generatedAs === void 0 && r.push(e);
+	}
+	return r;
+};
+//#endregion
+export { n as prepareInsertRequiredColumns };

package/dist/inspectWorkflow.js

@@ -0,0 +1 @@
+export { inspectWorkflow } from "@voltro/workflow";

package/dist/instanceMembership.js

@@ -0,0 +1,98 @@
+import { createLogger as e } from "@voltro/logger";
+//#region src/instanceMembership.ts
+var t = e({ scope: "voltro:members" }), n = 5e3, r = class {
+	members = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	instanceId;
+	startedAt;
+	meta;
+	heartbeatMs;
+	downAfterMs;
+	announce;
+	now;
+	timer;
+	constructor(e) {
+		this.instanceId = e.instanceId, this.now = e.now ?? Date.now, this.startedAt = e.startedAt ?? this.now(), this.meta = e.meta, this.heartbeatMs = e.heartbeatMs ?? n, this.downAfterMs = e.downAfterMs ?? this.heartbeatMs * 3, this.announce = e.announce, this.members.set(this.instanceId, {
+			startedAt: this.startedAt,
+			meta: this.meta,
+			lastHeardAt: this.now()
+		});
+	}
+	get id() {
+		return this.instanceId;
+	}
+	start() {
+		this.timer === void 0 && (this.beat(), this.timer = setInterval(() => {
+			this.beat(), this.sweep();
+		}, this.heartbeatMs), this.timer.unref?.());
+	}
+	stop() {
+		this.timer !== void 0 && (clearInterval(this.timer), this.timer = void 0);
+	}
+	beat() {
+		let e = this.members.get(this.instanceId);
+		if (e !== void 0 && (e.lastHeardAt = this.now()), this.announce !== void 0) try {
+			this.announce({
+				instanceId: this.instanceId,
+				startedAt: this.startedAt,
+				...this.meta === void 0 ? {} : { meta: this.meta }
+			});
+		} catch (e) {
+			t.warn("membership: announce failed", { cause: e });
+		}
+	}
+	receive(e) {
+		if (e.instanceId === this.instanceId) return;
+		let t = this.members.get(e.instanceId), n = this.now();
+		t === void 0 ? (this.members.set(e.instanceId, {
+			startedAt: e.startedAt,
+			meta: e.meta,
+			lastHeardAt: n
+		}), this.emit({
+			kind: "joined",
+			instanceId: e.instanceId,
+			startedAt: e.startedAt
+		})) : t.startedAt === e.startedAt ? (t.lastHeardAt = n, t.meta = e.meta) : (t.startedAt = e.startedAt, t.meta = e.meta, t.lastHeardAt = n, this.emit({
+			kind: "restarted",
+			instanceId: e.instanceId,
+			startedAt: e.startedAt
+		}));
+	}
+	sweep() {
+		let e = this.now() - this.downAfterMs;
+		for (let [t, n] of this.members) t !== this.instanceId && (n.lastHeardAt > e || (this.members.delete(t), this.emit({
+			kind: "left",
+			instanceId: t,
+			reason: "silent"
+		})));
+	}
+	list() {
+		let e = Array(this.members.size), t = 0;
+		return this.members.forEach((n, r) => {
+			e[t++] = {
+				instanceId: r,
+				startedAt: n.startedAt,
+				meta: n.meta,
+				lastHeardAt: n.lastHeardAt,
+				self: r === this.instanceId
+			};
+		}), e;
+	}
+	onChange(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	emit(e) {
+		for (let n of this.listeners) try {
+			n(e);
+		} catch (n) {
+			t.warn("membership: listener threw", {
+				event: e.kind,
+				cause: n
+			});
+		}
+	}
+};
+//#endregion
+export { r as InstanceMembership };

package/dist/ivm.js

@@ -0,0 +1,125 @@
+//#region src/ivm.ts
+var e = /* @__PURE__ */ new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max"
+]), t = (t) => {
+	if (t.joins !== void 0 && t.joins.length > 0) return {
+		maintainable: !1,
+		reason: "joins are not maintainable in v1"
+	};
+	if (t.windowed === !0) return {
+		maintainable: !1,
+		reason: "window functions are not maintainable"
+	};
+	if (t.distinct === !0) return {
+		maintainable: !1,
+		reason: "distinct is not maintainable from a delta"
+	};
+	if (t.having !== void 0) return {
+		maintainable: !1,
+		reason: "having needs post-aggregate re-evaluation"
+	};
+	if (t.aggregations.length !== 1) return {
+		maintainable: !1,
+		reason: "v1 maintains exactly one aggregation"
+	};
+	let n = t.aggregations[0];
+	return e.has(n.op) ? n.op !== "count" && (n.column === void 0 || n.column.length === 0) ? {
+		maintainable: !1,
+		reason: `op '${n.op}' requires a column`
+	} : {
+		maintainable: !0,
+		shape: {
+			op: n.op,
+			...n.column === void 0 ? {} : { column: n.column },
+			...t.groupBy !== void 0 && t.groupBy.length > 0 ? { groupBy: t.groupBy } : {}
+		}
+	} : {
+		maintainable: !1,
+		reason: `op '${n.op}' is not maintainable`
+	};
+}, n = "\0", r = (e, t) => t === void 0 || t.length === 0 ? "" : t.map((t) => JSON.stringify(e[t] ?? null)).join(n), i = (e, t) => t === void 0 ? 0 : Number(e[t] ?? 0), a = (e, t) => {
+	switch (e.op) {
+		case "count": return t.count;
+		case "sum": return t.sum ?? 0;
+		case "avg": return t.count > 0 ? (t.sum ?? 0) / t.count : null;
+		case "min":
+		case "max": return t.count > 0 ? t.extreme ?? null : null;
+	}
+}, o = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let a of t) {
+		let t = r(a, e.groupBy), o = n.get(t), s = i(a, e.column);
+		if (o === void 0) n.set(t, {
+			count: 1,
+			...e.op === "sum" || e.op === "avg" ? { sum: s } : {},
+			...e.op === "min" || e.op === "max" ? { extreme: s } : {}
+		});
+		else {
+			let r = e.op === "min" ? Math.min(o.extreme ?? s, s) : e.op === "max" ? Math.max(o.extreme ?? s, s) : o.extreme;
+			n.set(t, {
+				count: o.count + 1,
+				...e.op === "sum" || e.op === "avg" ? { sum: (o.sum ?? 0) + s } : {},
+				...e.op === "min" || e.op === "max" ? { extreme: r } : {}
+			});
+		}
+	}
+	return n;
+}, s = (e, t) => [...t.entries()].map(([t, n]) => ({
+	groupKey: t,
+	value: a(e, n)
+})), c = (e, t, n) => l(e, new Map(t), n), l = (e, t, n, a) => {
+	let o = /* @__PURE__ */ new Set(), s = (n) => {
+		let s = r(n, e.groupBy), c = t.get(s);
+		if (c === void 0) return;
+		let l = c.count - 1;
+		if (l <= 0) {
+			t.delete(s), a?.removed(s);
+			return;
+		}
+		let u = i(n, e.column);
+		e.op === "min" || e.op === "max" ? (c.extreme !== void 0 && u === c.extreme && o.add(s), t.set(s, {
+			count: l,
+			...c.extreme === void 0 ? {} : { extreme: c.extreme }
+		})) : t.set(s, {
+			count: l,
+			...e.op === "sum" || e.op === "avg" ? { sum: (c.sum ?? 0) - u } : {}
+		});
+	}, c = (n) => {
+		let o = r(n, e.groupBy), s = t.get(o), c = i(n, e.column);
+		if (s === void 0) {
+			a?.added(o), t.set(o, {
+				count: 1,
+				...e.op === "sum" || e.op === "avg" ? { sum: c } : {},
+				...e.op === "min" || e.op === "max" ? { extreme: c } : {}
+			});
+			return;
+		}
+		let l = e.op === "min" ? Math.min(s.extreme ?? c, c) : e.op === "max" ? Math.max(s.extreme ?? c, c) : s.extreme;
+		t.set(o, {
+			count: s.count + 1,
+			...e.op === "sum" || e.op === "avg" ? { sum: (s.sum ?? 0) + c } : {},
+			...e.op === "min" || e.op === "max" ? { extreme: l } : {}
+		});
+	};
+	return n.op === "insert" && n.new ? c(n.new) : n.op === "delete" && n.old ? s(n.old) : n.op === "update" && (n.old && s(n.old), n.new && c(n.new)), {
+		state: t,
+		rescanGroups: [...o]
+	};
+}, u = (e, t, n, r) => {
+	if (n.length === 0) return t;
+	let i = new Map(t);
+	return d(e, i, n, r), i;
+}, d = (e, t, n, i) => {
+	if (n.length === 0) return;
+	let a = new Set(n), s = o(e, i.filter((t) => a.has(r(t, e.groupBy))));
+	for (let e of a) {
+		let n = s.get(e);
+		n === void 0 ? t.delete(e) : t.set(e, n);
+	}
+};
+//#endregion
+export { c as applyDelta, l as applyDeltaInto, o as buildIvmState, t as classifyShape, r as groupKeyOf, a as ivmValue, s as materializeIvm, u as resolveRescan, d as resolveRescanInto };

package/dist/kvDataStore.js

@@ -0,0 +1,86 @@
+import { Effect as e, Option as t } from "effect";
+import { and as n, contains as r, eq as i, generateId as a, gt as o, isNull as s, or as c } from "@voltro/database";
+import { KvError as l } from "@voltro/kv";
+//#region src/kvDataStore.ts
+var u = "_voltro_kv", d = (e) => {
+	if (e == null) return null;
+	if (e instanceof Date) return e.getTime();
+	if (typeof e == "number") return e;
+	let t = Date.parse(String(e));
+	return Number.isNaN(t) ? null : t;
+}, f = (e, t) => {
+	let n = d(e.expiresAt);
+	return n !== null && n <= t;
+}, p = (e) => e === null ? null : JSON.parse(e), m = async (e, t) => (await e.query({
+	table: u,
+	predicate: i("key", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0] ?? null, h = (i) => {
+	let d = (t, n, r) => e.tryPromise({
+		try: r,
+		catch: (e) => new l({
+			operation: t,
+			key: n,
+			cause: String(e)
+		})
+	});
+	return {
+		get: (e) => d("get", e, async () => {
+			let n = await m(i, e);
+			return n === null ? t.none() : f(n, Date.now()) ? (await i.delete(u, n.id), t.none()) : t.some(p(n.value));
+		}),
+		set: (e, t, n) => d("set", e, async () => {
+			let r = Date.now(), o = n?.ttlMs !== void 0 && n.ttlMs > 0 ? new Date(r + n.ttlMs) : null, s = a({
+				kind: "typeid",
+				prefix: "kv"
+			}, u);
+			await i.upsert(u, {
+				id: s,
+				key: e,
+				value: JSON.stringify(t),
+				expiresAt: o,
+				updatedAt: new Date(r)
+			}, {
+				conflictColumns: ["key"],
+				update: [
+					"value",
+					"expiresAt",
+					"updatedAt"
+				]
+			});
+		}),
+		delete: (e) => d("delete", e, async () => {
+			let t = await m(i, e);
+			if (t === null) return !1;
+			let n = !f(t, Date.now());
+			return await i.delete(u, t.id), n;
+		}),
+		has: (e) => d("has", e, async () => {
+			let t = await m(i, e);
+			return t === null ? !1 : !f(t, Date.now()) || (await i.delete(u, t.id), !1);
+		}),
+		list: (e) => d("list", "", async () => {
+			let t = Date.now(), a = c(s("expiresAt"), o("expiresAt", new Date(t))), l = e === "" ? a : n(r("key", e), a), d = await i.query({
+				table: u,
+				predicate: l,
+				order: [],
+				take: void 0,
+				skip: void 0,
+				projection: void 0
+			}), p = [];
+			for (let n of d) f(n, t) || (e === "" || n.key.startsWith(e)) && p.push(n.key);
+			return p;
+		}),
+		clear: () => d("clear", "", async () => {
+			await i.deleteMany(u, { where: {
+				column: "id",
+				op: "isNotNull"
+			} });
+		})
+	};
+};
+//#endregion
+export { h as dataStoreKvStore };

package/dist/kvFacade.js

@@ -0,0 +1,32 @@
+import { dataStoreKvStore as e } from "./kvDataStore.js";
+import { Layer as t, ManagedRuntime as n, Option as r } from "effect";
+import { LoggerLayer as i } from "@voltro/logger";
+import { Kv as a, KvStore as o, layerConnections as s, layerMemory as c, layerRedis as l } from "@voltro/kv";
+//#region src/kvFacade.ts
+var u = async ({ store: u, env: d = process.env }) => {
+	let f = (d.KV_BACKEND ?? "database").toLowerCase(), p = f === "redis" ? "redis" : f === "memory" ? "memory" : "database", m = p === "redis" ? l(d.KV_KEY_PREFIX ? { keyPrefix: d.KV_KEY_PREFIX } : {}).pipe(t.provide(s)) : p === "memory" ? c() : t.succeed(o, o.of(e(u))), h = n.make(a.layer.pipe(t.provide(m), t.provideMerge(i({})))), g = await h.runPromise(a);
+	return {
+		kv: {
+			get: (e) => h.runPromise(g.get(e)).then((e) => r.getOrUndefined(e)),
+			getOrElse: (e, t) => h.runPromise(g.getOrElse(e, t)),
+			set: (e, t, n) => h.runPromise(g.set(e, t, n)),
+			delete: (e) => h.runPromise(g.delete(e)),
+			has: (e) => h.runPromise(g.has(e)),
+			list: (e) => h.runPromise(g.list(e)),
+			clear: () => h.runPromise(g.clear())
+		},
+		service: g,
+		backend: p,
+		dispose: () => h.dispose()
+	};
+}, d = {
+	get: () => Promise.resolve(void 0),
+	getOrElse: (e, t) => Promise.resolve(t()),
+	set: () => Promise.resolve(),
+	delete: () => Promise.resolve(!1),
+	has: () => Promise.resolve(!1),
+	list: () => Promise.resolve([]),
+	clear: () => Promise.resolve()
+};
+//#endregion
+export { u as makeAsyncKv, d as noopKv };

package/dist/matcher.js

@@ -0,0 +1,304 @@
+import { RangeIndex as e } from "./rangeIndex.js";
+import { evaluatePredicate as t, getTable as n, walkLeaves as r } from "@voltro/database";
+//#region src/matcher.ts
+var i = class {
+	byTable = /* @__PURE__ */ new Map();
+	register(e) {
+		let t = this.byTable.get(e.table);
+		t || (t = /* @__PURE__ */ new Map(), this.byTable.set(e.table, t)), t.set(e.id, e);
+	}
+	unregister(e, t) {
+		this.byTable.get(t)?.delete(e);
+	}
+	size(e) {
+		return this.byTable.get(e)?.size ?? 0;
+	}
+	match(e) {
+		let r = this.byTable.get(e.table);
+		if (!r) return [];
+		let i = [];
+		for (let a of r.values()) {
+			let r = e.old ? t(a.predicate, e.old, null, n(e.table)?.fields) : !1, o = e.new ? t(a.predicate, e.new, null, n(e.table)?.fields) : !1;
+			(r || o) && i.push({
+				subId: a.id,
+				oldMatched: r,
+				newMatched: o
+			});
+		}
+		return i;
+	}
+	stats() {
+		let e = [];
+		for (let [t, n] of this.byTable) e.push({
+			tableName: t,
+			tupleRouted: 0,
+			columnBucketed: 0,
+			rangeBucketed: 0,
+			unindexedFallback: n.size,
+			tupleBucketCount: 0,
+			columnBucketCount: 0,
+			rangeBucketCount: 0,
+			distinctTupleKeys: 0
+		});
+		return { perTable: e };
+	}
+}, a = (e) => {
+	let t = [];
+	for (let n of r(e)) n.conjunctive && n.path === void 0 && (n.op === "eq" && t.push({
+		column: n.column,
+		values: [n.value]
+	}), n.op === "in" && t.push({
+		column: n.column,
+		values: n.value
+	}));
+	return t;
+}, o = (e) => {
+	let t = [];
+	for (let n of r(e)) n.conjunctive && n.path === void 0 && (n.op === "gt" || n.op === "gte" || n.op === "lt" || n.op === "lte") && t.push({
+		column: n.column,
+		op: n.op,
+		threshold: n.value
+	});
+	return t;
+}, s = (e, t) => {
+	for (let n of r(e)) if (n.conjunctive && n.path === void 0 && n.op === "eq" && n.column === t) return n.value;
+	return null;
+}, c = (e, t) => {
+	let n = [];
+	for (let r of e) {
+		let e = t(r);
+		if (e === null) return null;
+		n.push(`${typeof e}:${String(e)}`);
+	}
+	return n.join("|");
+}, l = (e, t) => e === null || t === null ? null : e === t ? 0 : typeof e == typeof t ? e > t ? 1 : -1 : null, u = (e, t, n) => {
+	let r = l(e, n);
+	if (r === null) return !1;
+	switch (t) {
+		case "gt": return r > 0;
+		case "gte": return r >= 0;
+		case "lt": return r < 0;
+		case "lte": return r <= 0;
+	}
+}, d = class {
+	columnByTable = /* @__PURE__ */ new Map();
+	rangeByTable = /* @__PURE__ */ new Map();
+	tupleByTable = /* @__PURE__ */ new Map();
+	compositeByTable = /* @__PURE__ */ new Map();
+	unindexedByTable = /* @__PURE__ */ new Map();
+	subscriptions = /* @__PURE__ */ new Map();
+	register(t) {
+		let r = this.subscriptions.get(t.id);
+		r !== void 0 && this.unregister(t.id, r.record.table), this.columnByTable.has(t.table) || this.columnByTable.set(t.table, /* @__PURE__ */ new Map()), this.rangeByTable.has(t.table) || this.rangeByTable.set(t.table, /* @__PURE__ */ new Map()), this.tupleByTable.has(t.table) || this.tupleByTable.set(t.table, /* @__PURE__ */ new Map()), this.unindexedByTable.has(t.table) || this.unindexedByTable.set(t.table, /* @__PURE__ */ new Set());
+		let i = n(t.table)?.fields, l = (e) => i?.[e]?.type !== "decimal", u = a(t.predicate), d = 0;
+		for (let e of u) l(e.column) && (u[d++] = e);
+		u.length = d;
+		let f = o(t.predicate);
+		d = 0;
+		for (let e of f) l(e.column) && (f[d++] = e);
+		if (f.length = d, t.usingIndex !== void 0 && t.usingIndex.fields.every(l)) {
+			let e = t.usingIndex, n = c(e.fields, (e) => s(t.predicate, e));
+			if (n !== null) {
+				let r = JSON.stringify([e.name, e.fields]), i = `${r}|${n}`, a = this.compositeByTable.get(t.table);
+				a === void 0 && (a = /* @__PURE__ */ new Map(), this.compositeByTable.set(t.table, a));
+				let o = a.get(r);
+				o === void 0 ? a.set(r, {
+					fields: [...e.fields],
+					references: 1
+				}) : o.references += 1;
+				let s = this.tupleByTable.get(t.table), c = s.get(i);
+				c || (c = /* @__PURE__ */ new Set(), s.set(i, c)), c.add(t.id), this.subscriptions.set(t.id, {
+					record: t,
+					tupleBucketKey: i,
+					tupleDefinitionKey: r,
+					constraints: this.constraintsFor(u, f),
+					routing: "tuple"
+				});
+				return;
+			}
+		}
+		let p = u.length > 0, m = f.length > 0;
+		if (!p && !m) this.unindexedByTable.get(t.table).add(t.id), this.subscriptions.set(t.id, {
+			record: t,
+			tupleBucketKey: null,
+			constraints: [],
+			routing: "unindexed"
+		});
+		else {
+			if (p) {
+				let e = this.columnByTable.get(t.table);
+				for (let n of u) {
+					let r = e.get(n.column);
+					r || (r = /* @__PURE__ */ new Map(), e.set(n.column, r));
+					for (let e of n.values) {
+						let n = r.get(e);
+						n || (n = /* @__PURE__ */ new Set(), r.set(e, n)), n.add(t.id);
+					}
+				}
+			}
+			if (m) {
+				let n = this.rangeByTable.get(t.table);
+				for (let r of f) {
+					let i = n.get(r.column);
+					i || (i = /* @__PURE__ */ new Map(), n.set(r.column, i));
+					let a = i.get(r.op);
+					a || (a = new e(), i.set(r.op, a)), a.add(t.id, r.threshold);
+				}
+			}
+			this.subscriptions.set(t.id, {
+				record: t,
+				tupleBucketKey: null,
+				equalityMemberships: u,
+				rangeMemberships: f,
+				constraints: this.constraintsFor(u, f),
+				routing: p ? "column" : "range"
+			});
+		}
+	}
+	constraintsFor(e, t) {
+		let n = [];
+		for (let t of e) t.values.length === 1 && n.push({
+			kind: "eq",
+			column: t.column,
+			value: t.values[0]
+		});
+		for (let e of t) n.push({
+			kind: "range",
+			column: e.column,
+			op: e.op,
+			threshold: e.threshold
+		});
+		return n;
+	}
+	unregister(e, t) {
+		let n = this.subscriptions.get(e);
+		if (n !== void 0 && n.record.table === t) {
+			if (this.subscriptions.delete(e), this.unindexedByTable.get(t)?.delete(e), n.tupleBucketKey !== null) {
+				let r = this.tupleByTable.get(t), i = r?.get(n.tupleBucketKey);
+				i?.delete(e), i !== void 0 && i.size === 0 && r?.delete(n.tupleBucketKey);
+				let a = this.compositeByTable.get(t), o = n.tupleDefinitionKey;
+				if (o !== void 0) {
+					let e = a?.get(o);
+					e !== void 0 && --e.references === 0 && a?.delete(o);
+				}
+			} else {
+				let r = this.columnByTable.get(t);
+				for (let t of n.equalityMemberships ?? []) {
+					let n = r?.get(t.column);
+					for (let r of t.values) {
+						let t = n?.get(r);
+						t?.delete(e), t?.size === 0 && n?.delete(r);
+					}
+					n?.size === 0 && r?.delete(t.column);
+				}
+				let i = this.rangeByTable.get(t);
+				for (let t of n.rangeMemberships ?? []) {
+					let n = i?.get(t.column), r = n?.get(t.op);
+					r?.delete(e), r?.size === 0 && n?.delete(t.op), n?.size === 0 && i?.delete(t.column);
+				}
+			}
+			for (let e of [
+				this.columnByTable,
+				this.rangeByTable,
+				this.tupleByTable,
+				this.unindexedByTable,
+				this.compositeByTable
+			]) e.get(t)?.size === 0 && e.delete(t);
+		}
+	}
+	size(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let n of this.unindexedByTable.get(e) ?? []) t.add(n);
+		let n = this.columnByTable.get(e);
+		if (n) for (let e of n.values()) for (let n of e.values()) for (let e of n) t.add(e);
+		let r = this.rangeByTable.get(e);
+		if (r) for (let e of r.values()) for (let n of e.values()) for (let e of n.keys()) t.add(e);
+		let i = this.tupleByTable.get(e);
+		if (i) for (let e of i.values()) for (let n of e) t.add(n);
+		return t.size;
+	}
+	stats() {
+		let e = /* @__PURE__ */ new Set([
+			...this.columnByTable.keys(),
+			...this.rangeByTable.keys(),
+			...this.tupleByTable.keys(),
+			...this.unindexedByTable.keys()
+		]), t = [];
+		for (let n of e) {
+			let e = 0, r = 0, i = 0, a = 0;
+			for (let t of this.subscriptions.values()) t.record.table === n && (t.routing === "tuple" ? e += 1 : t.routing === "column" ? r += 1 : t.routing === "range" ? i += 1 : a += 1);
+			let o = this.tupleByTable.get(n), s = this.columnByTable.get(n), c = this.rangeByTable.get(n), l = 0, u = 0;
+			if (o) {
+				u = o.size;
+				for (let e of o.values()) e.size > 0 && (l += 1);
+			}
+			let d = 0;
+			if (s) for (let e of s.values()) d += e.size;
+			let f = 0;
+			if (c) for (let e of c.values()) f += e.size;
+			t.push({
+				tableName: n,
+				tupleRouted: e,
+				columnBucketed: r,
+				rangeBucketed: i,
+				unindexedFallback: a,
+				tupleBucketCount: u,
+				columnBucketCount: d,
+				rangeBucketCount: f,
+				distinctTupleKeys: l
+			});
+		}
+		return { perTable: t };
+	}
+	candidatesFor(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		for (let t of this.unindexedByTable.get(e) ?? []) n.add(t);
+		let r = this.tupleByTable.get(e);
+		if (r && r.size > 0) for (let [i, a] of this.compositeByTable.get(e) ?? []) {
+			let e = c(a.fields, (e) => t[e]);
+			if (e === null) continue;
+			let o = r.get(`${i}|${e}`);
+			if (o) for (let e of o) n.add(e);
+		}
+		let i = this.columnByTable.get(e);
+		if (i) for (let [e, r] of i) {
+			let i = t[e], a = r.get(i);
+			if (a) for (let e of a) n.add(e);
+		}
+		let a = this.rangeByTable.get(e);
+		if (a) for (let [e, r] of a) {
+			let i = t[e];
+			if (i !== null) for (let [e, t] of r) for (let r of t.candidates(i, e, (t) => u(i, e, t))) n.add(r);
+		}
+		return n;
+	}
+	allConstraintsMatch(e, t) {
+		for (let n of e.constraints) {
+			let e = t[n.column];
+			if (n.kind === "eq") {
+				if (e !== n.value) return !1;
+			} else if (!u(e, n.op, n.threshold)) return !1;
+		}
+		return !0;
+	}
+	match(e) {
+		let r = e.old ? this.candidatesFor(e.table, e.old) : /* @__PURE__ */ new Set(), i = e.new ? this.candidatesFor(e.table, e.new) : /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set([...r, ...i]);
+		if (a.size === 0) return [];
+		let o = [];
+		for (let s of a) {
+			let a = this.subscriptions.get(s);
+			if (!a) continue;
+			let c = e.old, l = e.new, u = c !== null && r.has(s) && this.allConstraintsMatch(a, c), d = l !== null && i.has(s) && this.allConstraintsMatch(a, l);
+			if (!u && !d) continue;
+			let f = u ? t(a.record.predicate, c, null, n(e.table)?.fields) : !1, p = d ? t(a.record.predicate, l, null, n(e.table)?.fields) : !1;
+			(f || p) && o.push({
+				subId: s,
+				oldMatched: f,
+				newMatched: p
+			});
+		}
+		return o;
+	}
+};
+//#endregion
+export { d as IndexedMatcher, i as LinearScanMatcher };

package/dist/memoryColumnDefaults.js

@@ -0,0 +1,11 @@
+import { getTable as e } from "@voltro/database";
+//#region src/memoryColumnDefaults.ts
+var t = (t, n) => {
+	let r = e(t);
+	if (r === void 0) return n;
+	let i = { ...n };
+	for (let [e, t] of Object.entries(r.fields)) i[e] === void 0 && t.generatedAs === void 0 && t.computed === void 0 && (t.hasDefault && t.defaultFactory === void 0 && t.defaultValue !== void 0 ? i[e] = t.defaultValue === "now" ? /* @__PURE__ */ new Date() : structuredClone(t.defaultValue) : t.nullable && t.defaultFactory === void 0 && (i[e] = null));
+	return i;
+};
+//#endregion
+export { t as applyMemoryColumnDefaults };