@voltro/runtime 0.86.0 → 0.88.0

package/dist/fieldKeyScan.js

@@ -0,0 +1,135 @@
+import { FIELD_KEYS_TABLE as e, FIELD_KEY_HOLDERS_TABLE as t } from "./fieldKeyRegistry.js";
+import { Effect as n } from "effect";
+import { ciphertextKeyId as r, encryptedColumnsOf as i, quoteIdent as a } from "@voltro/database";
+import { SqlClient as o } from "effect/sql";
+import { introspectSchema as s } from "@voltro/database/sql";
+// src/fieldKeyScan.ts
+var c = /enc:v[12]:[A-Za-z0-9+/=:_-]+/g, l = 500, u = /* @__PURE__ */ new Set(["text", "json"]), d = (e, t, n) => e === "postgres" ? `CAST(${t} AS TEXT)` : n === "json" && (e === "mysql" || e === "mariadb") ? `CAST(${t} AS CHAR)` : t, f = (e) => {
+	let t = e instanceof Error ? e.message : String(e);
+	for (let n = e?.cause; n instanceof Error; n = n.cause) t = n.message;
+	return t;
+}, p = (e) => typeof e == "number" || typeof e == "bigint" ? String(e) : `'${String(e).replaceAll("'", "''")}'`, m = (e) => typeof e == "string" ? e : e instanceof Uint8Array ? new TextDecoder().decode(e) : e == null ? "" : JSON.stringify(e), h = (e, t) => n.gen(function* () {
+	let r = yield* o.SqlClient, i = (t) => a(t, e), c = yield* s(r), l = [], m = [];
+	for (let a of c.tables) {
+		if (a.name === "_voltro_field_keys" || a.name === "_voltro_field_key_holders") continue;
+		let o = a.indexes.find((e) => e.name === `${a.name}_pkey`)?.columns, s = o?.length === 1 ? o[0] : void 0;
+		for (let o of a.columns) {
+			let c = t.get(a.name)?.has(o.name) === !0;
+			if (!c && !u.has(o.type)) continue;
+			let h = d(e, `${i("__t")}.${i(o.name)}`, o.type), g = `${h} LIKE '%enc:v%'`, _ = `${i(a.name)} ${i("__t")}`, v = yield* r.unsafe(`SELECT COUNT(*) AS n FROM ${_} WHERE ${g}`).unprepared.pipe(n.map((e) => Number(e[0]?.n ?? 0)), n.catch((e) => n.sync(() => {
+				m.push({
+					table: a.name,
+					column: o.name,
+					reason: f(e)
+				});
+			})));
+			v === void 0 || v === 0 && !c || l.push({
+				table: a.name,
+				column: o.name,
+				type: o.type,
+				declared: c,
+				key: s,
+				found: v,
+				asText: d(e, i(o.name), o.type),
+				page: (t, n) => {
+					if (s === void 0) return `SELECT ${h} AS ${i("__v")}, ${i("__t")}.* FROM ${_} WHERE ${g}`;
+					let r = `${i("__t")}.${i(s)} AS ${i("__k")}, ${h} AS ${i("__v")}, ${i("__t")}.*`, a = `WHERE ${g}${t === void 0 ? "" : ` AND ${i("__t")}.${i(s)} > ${p(t)}`} ORDER BY ${i("__t")}.${i(s)}`;
+					return e === "mssql" ? `SELECT TOP ${n} ${r} FROM ${_} ${a}` : `SELECT ${r} FROM ${_} ${a} LIMIT ${n}`;
+				}
+			});
+		}
+	}
+	return {
+		columns: l,
+		unreadable: m,
+		tables: new Set(c.tables.map((e) => e.name))
+	};
+}), g = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n;
+		if (typeof e != "object" || !e || typeof e.fields != "object" || e.tableName === void 0) continue;
+		let r = i(e);
+		r.length > 0 && t.set(e.tableName, new Set(r));
+	}
+	return t;
+}, _ = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n;
+		if (typeof e != "object" || !e || typeof e.fields != "object" || e.tableName === void 0) continue;
+		let r = /* @__PURE__ */ new Map();
+		for (let t of i(e)) {
+			let n = e.fields[t]?.renamedFrom;
+			n !== void 0 && r.set(t, n);
+		}
+		(e.previousTableName !== void 0 || r.size > 0) && t.set(e.tableName, {
+			...e.previousTableName === void 0 ? {} : { previousTable: e.previousTableName },
+			columns: r
+		});
+	}
+	return t;
+}, v = (e, t, n = 1) => {
+	e[t] = (e[t] ?? 0) + n;
+}, y = (i, s) => n.gen(function* () {
+	let u = yield* o.SqlClient, d = (e) => a(e, i), p = (e) => u.unsafe(e).unprepared, { columns: _, unreadable: y, tables: b } = yield* h(i, g(s)), x = [...y], S = [];
+	for (let e of _) {
+		let t = yield* n.gen(function* () {
+			let t = e.declared ? Number((yield* p(`SELECT COUNT(*) AS n FROM ${d(e.table)} WHERE ${d(e.column)} IS NOT NULL AND ${e.asText} NOT LIKE 'enc:v%'`))[0]?.n ?? 0) : 0, n = {}, i = 0, a = 0, o = (e) => {
+				let t = m(e).match(c) ?? [];
+				t.length > 0 && (a += 1);
+				for (let e of t) {
+					let t = r(e);
+					t === void 0 ? i += 1 : v(n, t);
+				}
+			};
+			if (e.found > 0) {
+				let t;
+				for (;;) {
+					let n = yield* p(e.page(t, l));
+					for (let e of n) o(e.__v);
+					if (e.key === void 0 || n.length < l) break;
+					t = n[n.length - 1].__k;
+				}
+			}
+			return {
+				table: e.table,
+				column: e.column,
+				declared: e.declared,
+				cells: a,
+				byKey: n,
+				unnamed: i,
+				plaintext: t
+			};
+		}).pipe(n.catch((t) => n.sync(() => {
+			x.push({
+				table: e.table,
+				column: e.column,
+				reason: f(t)
+			});
+		})));
+		t !== void 0 && S.push(t);
+	}
+	let C = (e) => e == null ? null : e instanceof Date ? e.toISOString() : String(e), w = b.has("_voltro_field_keys") ? (yield* p(`SELECT ${d("keyId")} AS k, ${d("state")} AS s, ${d("activatedAt")} AS a, ${d("requestedAt")} AS r FROM ${d(e)}`)).map((e) => ({
+		keyId: String(e.k),
+		state: String(e.s),
+		activatedAt: C(e.a),
+		requestedAt: C(e.r)
+	})).sort((e, t) => e.keyId.localeCompare(t.keyId)) : [], T = b.has("_voltro_field_key_holders") ? (yield* p(`SELECT ${d("holderId")} AS h, ${d("keyIds")} AS k, ${d("activeKeyId")} AS a, ${d("expiresAt")} AS e FROM ${d(t)}`)).map((e) => ({
+		holderId: String(e.h),
+		keyIds: String(e.k).split(","),
+		activeKeyId: String(e.a),
+		expiresAt: C(e.e) ?? ""
+	})).sort((e, t) => e.holderId.localeCompare(t.holderId)) : [], E = {};
+	for (let e of S) for (let [t, n] of Object.entries(e.byKey)) v(E, t, n);
+	return S.sort((e, t) => e.table.localeCompare(t.table) || e.column.localeCompare(t.column)), {
+		keys: w,
+		holders: T,
+		locations: S,
+		totals: E,
+		unreadable: x,
+		unnamed: S.reduce((e, t) => e + t.unnamed, 0),
+		plaintext: S.reduce((e, t) => e + t.plaintext, 0)
+	};
+});
+export { c as ENVELOPE_PATTERN, m as cellText, g as declaredEncryptedColumns, _ as declaredRenames, h as discoverSealedColumns, y as fieldKeyStatus, f as reasonOf };

package/dist/fieldKeyring.js

@@ -0,0 +1,76 @@
+import { FieldKeyringConfigError as e, deriveKey as t, fieldKeyIdOf as n } from "./fieldCipher.js";
+// src/fieldKeyring.ts
+var r = "VOLTRO_FIELD_ENCRYPTION_KEYS", i = "VOLTRO_FIELD_ENCRYPTION_ACTIVE", a = "VOLTRO_FIELD_ENCRYPTION_KEY", o = "VOLTRO_FIELD_ENCRYPTION_KEY_PREVIOUS", s = [
+	r,
+	i,
+	a,
+	o
+], c = (e) => e !== void 0 && e.trim() !== "", l = (t) => {
+	let n = t.trim();
+	if (n.startsWith("{")) {
+		let t;
+		try {
+			t = JSON.parse(n);
+		} catch {
+			throw new e(`${r} starts like JSON but is not valid JSON`);
+		}
+		if (typeof t != "object" || !t || Array.isArray(t)) throw new e(`${r} as JSON must be an object of id → key`);
+		return Object.entries(t).map(([t, n]) => {
+			if (typeof n != "string") throw new e(`${r}: key "${t}" is not a string`);
+			return {
+				id: t,
+				secret: n
+			};
+		});
+	}
+	return n.split(",").map((e) => e.trim()).filter((e) => e !== "").map((t) => {
+		let n = t.indexOf("=");
+		if (n <= 0) throw new e(`${r}: every entry is id=key, and one is not`);
+		return {
+			id: t.slice(0, n).trim(),
+			secret: t.slice(n + 1).trim()
+		};
+	});
+}, u = (e, n) => t(e).equals(t(n)), d = (t) => {
+	let s = t[r], d = t[a], p = t[o], m = t[i]?.trim();
+	if (c(s)) {
+		let t = l(s);
+		for (let [n, i] of [[a, d], [o, p]]) if (c(i) && !t.some((e) => u(e.secret, i))) throw new e(`${n} is set beside ${r} but is not one of its keys — put it into ${r} or remove it`);
+		if (t.length === 0) throw new e(`${r} is set but holds no key`);
+		let n = c(d) ? t.find((e) => u(e.secret, d))?.id : void 0, h = c(m) ? m : t.length === 1 ? t[0].id : n;
+		if (h === void 0) throw new e(`${r} holds ${t.length} keys: name the one new values are sealed under in ${i}`);
+		return f({
+			active: h,
+			keys: t
+		}), {
+			active: h,
+			keys: t
+		};
+	}
+	if (!c(d)) {
+		if (c(p)) throw new e(`${o} is set without ${a}`);
+		return;
+	}
+	if (c(p) && u(d, p)) throw new e(`${a} and ${o} are the same key — a rotation needs a NEW key in ${a}`);
+	let h = [{
+		id: n(d),
+		secret: d
+	}, ...c(p) ? [{
+		id: n(p),
+		secret: p
+	}] : []], g = {
+		active: h[0].id,
+		keys: h
+	};
+	return f(g), g;
+}, f = (t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of t.keys) {
+		if (!/^[a-z0-9][a-z0-9-]{0,15}$/.test(r.id)) throw new e(`field encryption: "${r.id}" is not a key id — use a short lowercase slug (letters, digits, "-", at most 16)`);
+		if (n.has(r.id)) throw new e(`field encryption: key id "${r.id}" is configured twice`);
+		n.add(r.id);
+	}
+	for (let n = 0; n < t.keys.length; n++) for (let r = n + 1; r < t.keys.length; r++) if (u(t.keys[n].secret, t.keys[r].secret)) throw new e(`field encryption: keys "${t.keys[n].id}" and "${t.keys[r].id}" are the same key — a rotation needs a NEW key, and two ids for one key make every count per key wrong`);
+	if (!n.has(t.active)) throw new e(`field encryption: the active key "${t.active}" is not one of the configured keys (${[...n].join(", ")})`);
+};
+export { i as FIELD_ENCRYPTION_ACTIVE_ENV, r as FIELD_ENCRYPTION_KEYS_ENV, a as FIELD_ENCRYPTION_KEY_ENV, o as FIELD_ENCRYPTION_PREVIOUS_KEY_ENV, s as FIELD_KEYRING_ENV_NAMES, d as resolveFieldKeyring };

package/dist/fingerprint.js

@@ -1,5 +1,5 @@
 import { createHash as e } from "node:crypto";
-//#region src/fingerprint.ts
+// src/fingerprint.ts
 var t = (e) => {
 	if (e == null) return null;
 	if (Array.isArray(e)) return e.map(t);
@@ -17,5 +17,4 @@ var t = (e) => {
 	});
 	return e("sha256").update(JSON.stringify(a)).digest("hex").slice(0, 16);
 };
-//#endregion
 export { t as canonicalize, n as fingerprintFor };

package/dist/finops.js

@@ -1,5 +1,5 @@
 import { Context as e, Effect as t } from "effect";
-//#region src/finops.ts
+// src/finops.ts
 var n = /* @__PURE__ */ new Set([
 	"info",
 	"warn",
@@ -38,5 +38,4 @@ var n = /* @__PURE__ */ new Set([
 }, s = (e) => typeof e == "object" && !!e && e._voltroCostBudget === !0, c = class extends e.Service()("@voltro/CostRegistry") {}, l = (e, n) => t.gen(function* () {
 	return (yield* c).budget(e.name, n);
 });
-//#endregion
 export { c as CostRegistry, o as defineCostBudget, s as isCostBudgetDefinition, l as useCostBudget };

package/dist/finopsAccountant.js

@@ -1,4 +1,4 @@
-//#region src/finopsAccountant.ts
+// src/finopsAccountant.ts
 var e = class {
 	total = 0;
 	byUnit = /* @__PURE__ */ new Map();
@@ -212,5 +212,4 @@ var e = class {
 		runTick: u
 	};
 };
-//#endregion
 export { a as CostAccountant, o as attachFinops };

package/dist/handlerBody.js

@@ -1,8 +1,7 @@
 import { Effect as e } from "effect";
-//#region src/handlerBody.ts
+// src/handlerBody.ts
 function t(t, n) {
 	if (e.isEffect(t)) return n ? n(t) : e.runPromise(t);
 	if (t instanceof Promise) return t;
 }
-//#endregion
 export { t as settleHandlerBody };

package/dist/healthProbes.js

@@ -1,4 +1,4 @@
-//#region src/healthProbes.ts
+// src/healthProbes.ts
 var e = "/internal", t = (t, n) => ({
 	path: (t?.path ?? e).replace(/\/+$/, "") || e,
 	liveness: t?.liveness ?? (() => !0),
@@ -51,5 +51,4 @@ var e = "/internal", t = (t, n) => ({
 		};
 	}
 };
-//#endregion
 export { r as answerProbe, n as probeFor, t as resolveHealth };

package/dist/hot.d.ts

@@ -0,0 +1,56 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
+import { DialectId } from '@voltro/database';
+import { FieldDefinitions } from '@voltro/database';
+import { HotStoreShape } from '@voltro/kv/hot/contract';
+import { Table } from '@voltro/database';
+
+/** Small-deployment SQL backend. One database lock serializes complete batches.
+ * The lock row contains no application key, tenant identity or payload. All
+ * application rows, including sorted members, are physically removed on delete.
+ * SQL stores own transaction retries; callbacks perform no external side effects.
+ */
+export declare const dataStoreHotStore: (store: DataStore, options: HotDataStoreOptions) => HotStoreShape;
+
+export declare interface HotDataStoreOptions {
+    /** Actual SQL dialect: SQLite-family writer admission differs from row locks. */
+    readonly dialect: DialectId;
+    readonly namespace: string;
+    /** Trusted server/test time, sampled after acquiring the transaction lock. */
+    readonly now?: () => number;
+}
+
+export declare const hotDataStoreTables: readonly [ Table<"_voltro_hot_kv", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly namespace: ColumnBuilder<string | null, "text", boolean>;
+    readonly key: ColumnBuilder<string | null, "text", boolean>;
+    readonly payload: ColumnBuilder<string | null, "text", boolean>;
+    readonly expiresAtMs: ColumnBuilder<number | null, "real", boolean>;
+}>, false, never>, Table<"_voltro_hot_z", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly memberHash: ColumnBuilder<string, "text", boolean>;
+    readonly member: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<number, "real", boolean>;
+}>, false, never>];
+
+/** Activated with the database HotStore; importing definitions performs no I/O. */
+export declare const hotKvTable: Table<"_voltro_hot_kv", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly namespace: ColumnBuilder<string | null, "text", boolean>;
+    readonly key: ColumnBuilder<string | null, "text", boolean>;
+    readonly payload: ColumnBuilder<string | null, "text", boolean>;
+    readonly expiresAtMs: ColumnBuilder<number | null, "real", boolean>;
+}>, false, never>;
+
+export declare const hotZTable: Table<"_voltro_hot_z", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly memberHash: ColumnBuilder<string, "text", boolean>;
+    readonly member: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<number, "real", boolean>;
+}>, false, never>;
+
+export { }

package/dist/hot.js

@@ -0,0 +1,3 @@
+import { hotDataStoreTables as e, hotKvTable as t, hotZTable as n } from "./hotDataStoreTables.js";
+import { dataStoreHotStore as r } from "./hotDataStore.js";
+export { r as dataStoreHotStore, e as hotDataStoreTables, t as hotKvTable, n as hotZTable };

package/dist/hotDataStore.js

@@ -0,0 +1,147 @@
+import { decodeHotSnapshot as e, encodeHotSnapshot as t } from "./hotDataStoreSnapshot.js";
+import { hotKvTable as n, hotZTable as r } from "./hotDataStoreTables.js";
+import { Effect as i, Stream as a } from "effect";
+import { and as o, eq as s, generateId as c, gt as l, isNull as u, isSqliteFamily as d, or as f, queryFor as p, startsWith as m } from "@voltro/database";
+import { createHash as h } from "node:crypto";
+import { HotError as g, applyHotOperations as _, compareHotMembers as v, hotStoreFromRunner as y, validateHotOp as b } from "@voltro/kv/hot/contract";
+// src/hotDataStore.ts
+var x = n.tableName, S = r.tableName, C = "lock", w = (e) => h("sha256").update(e).digest("hex"), T = (h, T) => {
+	let { namespace: E } = T;
+	if (!E || !E.isWellFormed() || /[{}]/.test(E)) throw new g({
+		operation: "connect",
+		key: "",
+		reason: "invalid"
+	});
+	let D = T.now ?? Date.now, O = (e) => w(JSON.stringify([E, e])), k, A = () => k ??= h.transactional(async (e) => {
+		let t = {
+			id: c({
+				kind: "typeid",
+				prefix: "hot"
+			}, x),
+			keyHash: C,
+			namespace: null,
+			key: null,
+			payload: null,
+			expiresAtMs: null
+		};
+		T.dialect === "mssql" ? await e.upsert(x, t, {
+			conflictColumns: ["keyHash"],
+			update: []
+		}) : await e.insertIgnore(x, t, { conflictColumns: ["keyHash"] });
+	}).catch((e) => {
+		throw k = void 0, e;
+	}), j = async (t, i) => {
+		let a = O(i), o = (await t.query(p(n).where(s("keyHash", a)).descriptor))[0];
+		if (o === void 0) return;
+		if (o.namespace !== E || o.key !== i || typeof o.payload != "string") throw new g({
+			operation: "read",
+			key: i,
+			reason: "unavailable"
+		});
+		let c = o.expiresAtMs;
+		if (c !== null && (typeof c != "number" || !Number.isFinite(c))) throw new g({
+			operation: "read",
+			key: i,
+			reason: "unavailable"
+		});
+		let l = await t.query(p(r).where(s("keyHash", a)).descriptor), u = [];
+		for (let e of l) {
+			let t = e.member, n = e.score;
+			if (typeof t != "string" || typeof n != "number" || !Number.isFinite(n)) throw new g({
+				operation: "read",
+				key: i,
+				reason: "unavailable"
+			});
+			u.push([t, n]);
+		}
+		return e(o.payload, c === null ? Infinity : c, u);
+	}, M = async (e, n, r) => {
+		let i = O(n);
+		if (await e.deleteMany(S, { where: s("keyHash", i) }), r === void 0) await e.deleteMany(x, { where: s("keyHash", i) });
+		else if (await e.upsert(x, {
+			id: c({
+				kind: "typeid",
+				prefix: "hot"
+			}, x),
+			keyHash: i,
+			namespace: E,
+			key: n,
+			payload: t(r),
+			expiresAtMs: r.expiresAt === Infinity ? null : r.expiresAt
+		}, {
+			conflictColumns: ["keyHash"],
+			update: [
+				"namespace",
+				"key",
+				"payload",
+				"expiresAtMs"
+			]
+		}), r.kind === "z") for (let [t, n] of r.values) await e.insert(S, {
+			id: c({
+				kind: "typeid",
+				prefix: "hotz"
+			}, S),
+			keyHash: i,
+			memberHash: w(t),
+			member: t,
+			score: n
+		});
+	};
+	return y((e) => i.try({
+		try: () => {
+			e.forEach(b);
+		},
+		catch: (e) => e instanceof g ? e : new g({
+			operation: "multi",
+			key: "",
+			reason: "invalid"
+		})
+	}).pipe(i.flatMap(() => i.tryPromise({
+		try: async () => e.length === 0 ? [] : (await A(), h.transactional(async (t) => {
+			if (d(T.dialect) && await t.updateMany(x, { payload: null }, { where: s("keyHash", C) }), (await t.query(p(n).where(s("keyHash", C)).forUpdate().descriptor)).length !== 1) throw new g({
+				operation: "multi",
+				key: "",
+				reason: "unavailable"
+			});
+			let r = D();
+			if (!Number.isFinite(r)) throw new g({
+				operation: "multi",
+				key: "",
+				reason: "invalid"
+			});
+			let i = /* @__PURE__ */ new Map(), a = [...new Set(e.map((e) => e.key))];
+			for (let e of a) {
+				let n = await j(t, e);
+				n !== void 0 && i.set(e, n);
+			}
+			let o = new Map(i), c = _(i, e, r);
+			for (let e of a) i.get(e) !== o.get(e) && await M(t, e, i.get(e));
+			return c;
+		})),
+		catch: (e) => e instanceof g ? e : new g({
+			operation: "multi",
+			key: "",
+			reason: "unavailable"
+		})
+	}))), (e) => a.unwrap(i.tryPromise({
+		try: async () => {
+			if (!e.isWellFormed()) throw new g({
+				operation: "scanPrefix",
+				key: e,
+				reason: "invalid"
+			});
+			let t = D(), r = (await h.query(p(n).where(o(s("namespace", E), m("key", e), f(u("expiresAtMs"), l("expiresAtMs", t)))).descriptor)).flatMap((t) => t.namespace === E && typeof t.key == "string" && t.key.startsWith(e) && typeof t.payload == "string" ? [t.key] : []);
+			return a.fromIterable(r.sort(v));
+		},
+		catch: (t) => t instanceof g ? t : new g({
+			operation: "scanPrefix",
+			key: e,
+			reason: "unavailable"
+		})
+	})), {
+		atomicMulti: !0,
+		crossNode: !0,
+		persistent: !0
+	});
+};
+export { T as dataStoreHotStore };

package/dist/hotDataStoreSnapshot.js

@@ -0,0 +1,97 @@
+import { Schema as e } from "effect";
+// src/hotDataStoreSnapshot.ts
+var t = e.Number.pipe(e.check(e.makeFilter(Number.isFinite))), n = e.Union([
+	e.Struct({
+		kind: e.Literal("fixed"),
+		windowStart: t,
+		count: t
+	}),
+	e.Struct({
+		kind: e.Literal("sliding"),
+		currStart: t,
+		currCount: t,
+		prevCount: t
+	}),
+	e.Struct({
+		kind: e.Literal("token"),
+		tokens: t,
+		lastRefill: t
+	})
+]), r = e.Union([
+	e.Struct({ kind: e.Literal("z") }),
+	e.Struct({
+		kind: e.Literal("h"),
+		values: e.Array(e.Tuple([e.String, e.String]))
+	}),
+	e.Struct({
+		kind: e.Literal("s"),
+		values: e.Array(e.String)
+	}),
+	e.Struct({
+		kind: e.Literal("counter"),
+		value: t
+	}),
+	e.Struct({
+		kind: e.Literal("lease"),
+		value: e.String
+	}),
+	e.Struct({
+		kind: e.Literal("bucket"),
+		tokens: t,
+		updatedAt: t
+	}),
+	e.Struct({
+		kind: e.Literal("rateLimit"),
+		state: n
+	})
+]), i = e.decodeUnknownSync(r), a = (e) => {
+	switch (e.kind) {
+		case "z": return JSON.stringify({ kind: "z" });
+		case "h":
+		case "s": return JSON.stringify({
+			kind: e.kind,
+			values: [...e.values]
+		});
+		case "counter": return JSON.stringify({
+			kind: e.kind,
+			value: e.value
+		});
+		case "lease": return JSON.stringify({
+			kind: e.kind,
+			value: e.value
+		});
+		case "bucket": return JSON.stringify({
+			kind: e.kind,
+			tokens: e.tokens,
+			updatedAt: e.updatedAt
+		});
+		case "rateLimit": return JSON.stringify({
+			kind: e.kind,
+			state: e.state
+		});
+	}
+}, o = (e, t, n) => {
+	let r = i(JSON.parse(e));
+	switch (r.kind) {
+		case "z": return {
+			kind: "z",
+			values: new Map(n),
+			expiresAt: t
+		};
+		case "h": return {
+			kind: "h",
+			values: new Map(r.values),
+			expiresAt: t
+		};
+		case "s": return {
+			kind: "s",
+			values: new Set(r.values),
+			expiresAt: t
+		};
+		default: return {
+			...r,
+			expiresAt: t
+		};
+	}
+};
+export { o as decodeHotSnapshot, a as encodeHotSnapshot };

package/dist/hotDataStoreTables.js

@@ -0,0 +1,17 @@
+import { id as e, real as t, table as n, text as r } from "@voltro/database";
+// src/hotDataStoreTables.ts
+var i = n("_voltro_hot_kv", {
+	id: e({ prefix: "hot" }),
+	keyHash: r().maxLength(64),
+	namespace: r().nullable(),
+	key: r().nullable(),
+	payload: r().nullable(),
+	expiresAtMs: t().nullable()
+}).unique("hotKeyHash", ["keyHash"]).index(["expiresAtMs"]).nonReactive(), a = n("_voltro_hot_z", {
+	id: e({ prefix: "hotz" }),
+	keyHash: r().maxLength(64),
+	memberHash: r().maxLength(64),
+	member: r(),
+	score: t()
+}).unique("hotMemberHash", ["keyHash", "memberHash"]).index(["keyHash", "score"]).nonReactive(), o = [i, a];
+export { o as hotDataStoreTables, i as hotKvTable, a as hotZTable };

package/dist/http-range.d.ts

@@ -0,0 +1,53 @@
+/** The outcome of a `Range` header against a representation of `size` bytes. */
+export declare type ByteRangeRequest = 
+/** Absent, malformed, another unit, or several ranges: serve the whole thing. */
+    {
+    readonly _tag: 'ignored';
+}
+/** Syntactically valid, but no byte of it exists: 416 `bytes *\/size`. */
+| {
+    readonly _tag: 'unsatisfiable';
+}
+/** Serve bytes `start..end`, both inclusive: 206 `bytes start-end/size`. */
+| {
+    readonly _tag: 'satisfiable';
+    readonly start: number;
+    readonly end: number;
+};
+
+/**
+ * RFC 9110 §13.1.5: may a `Range` be honoured given this `If-Range`?
+ *
+ * `true` when there is no `If-Range`, or when it names the current
+ * representation by a STRONG validator: an identical strong entity tag, or
+ * the exact `Last-Modified` second — and only once that second is over
+ * (`nowMs`), because a file written twice within one second would otherwise
+ * keep a date that no longer names its bytes. A weak tag, an unparsable
+ * value, or a validator the representation does not have never matches: the
+ * client then gets the whole representation, never bytes of a different one.
+ */
+export declare const ifRangeAllowsRange: (ifRange: string | undefined, current: RangeValidators, nowMs?: number) => boolean;
+
+/**
+ * Resolve a `Range` header against a representation of `size` bytes
+ * (a non-negative safe integer, normally from `stat`).
+ */
+export declare const parseByteRange: (header: string | undefined, size: number) => ByteRangeRequest;
+
+/**
+ * An HTTP-date (RFC 9110 §5.6.7) in epoch milliseconds, `undefined` when the
+ * value is none. All three historical forms are accepted. asctime carries no
+ * zone and HTTP dates are always GMT, so it is read as GMT — `Date.parse`
+ * alone would read it in the server's local time zone.
+ */
+export declare const parseHttpDate: (value: string) => number | undefined;
+
+/** The current validators of the representation a range would be cut from. */
+export declare interface RangeValidators {
+    /** The representation's entity tag as sent in `ETag`, quotes included. */
+    readonly etag?: string | undefined;
+    /** Last modification time in epoch milliseconds (as sent in `Last-Modified`). */
+    readonly lastModifiedMs?: number | undefined;
+}
+
+export { }