@voltro/runtime 0.85.0 → 0.86.0

package/dist/outbox.js

@@ -0,0 +1,352 @@
+import { Effect as e } from "effect";
+import { and as t, eq as n, generateId as r, id as i, inSet as a, integer as o, json as s, lt as c, table as l, text as u, timestamp as d } from "@voltro/database";
+import { validateOutboxHandlerDefinition as f } from "@voltro/protocol";
+import { createLogger as p } from "@voltro/logger";
+//#region src/outbox.ts
+var m = p({ scope: "voltro:outbox" }), h = "_voltro_outbox", g = {
+	kind: "typeid",
+	prefix: "obx"
+}, _ = l(h, {
+	id: i({ prefix: "obx" }),
+	effect: u(),
+	payload: s(),
+	status: u(),
+	attempts: o(),
+	maxAttempts: o(),
+	nextAttemptAt: d(),
+	idempotencyKey: u().nullable(),
+	lastError: u().nullable(),
+	subjectId: u().nullable(),
+	tenantId: u().nullable(),
+	traceId: u().nullable(),
+	createdAt: d(),
+	deliveredAt: d().nullable(),
+	resendRequestedBy: u().nullable(),
+	resendRequestedAt: d().nullable(),
+	resendReason: u().nullable(),
+	resendCount: o(),
+	claimedBy: u().nullable(),
+	claimedAt: d().nullable()
+}), v = "_voltro_outbox_attempts", y = {
+	kind: "typeid",
+	prefix: "obxa"
+}, b = l(v, {
+	id: i({ prefix: "obxa" }),
+	outboxId: u(),
+	effect: u(),
+	attempt: o(),
+	trigger: u().oneOf(["automatic", "manual"]),
+	triggeredBy: u().nullable(),
+	reason: u().nullable(),
+	outcome: u().oneOf([
+		"delivered",
+		"failed",
+		"dead"
+	]),
+	startedAt: d(),
+	finishedAt: d(),
+	durationMs: o(),
+	error: u().nullable(),
+	response: s().nullable(),
+	subjectId: u().nullable(),
+	tenantId: u().nullable(),
+	traceId: u().nullable()
+}).index(["outboxId", "attempt"]).index(["startedAt"]).index(["outcome"]), x = (e) => (f(e, e.effect), e), S = 8, C = (e) => ({
+	enqueue: async (i, a, o) => {
+		let s = (e.now ?? (() => /* @__PURE__ */ new Date()))(), c = o?.idempotencyKey;
+		if (c !== void 0) {
+			let r = (await e.store.query({
+				table: h,
+				predicate: t(n("idempotencyKey", c), n("status", "pending")),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0];
+			if (r !== void 0) return r.id;
+		}
+		let l = {
+			id: r(g, h),
+			effect: i,
+			payload: a,
+			status: "pending",
+			attempts: 0,
+			maxAttempts: o?.maxAttempts ?? e.maxAttemptsOf?.(i) ?? S,
+			nextAttemptAt: new Date(s.getTime() + (o?.delayMs ?? 0)),
+			idempotencyKey: c ?? null,
+			lastError: null,
+			subjectId: e.subject.id ?? null,
+			tenantId: e.subject.tenantId ?? null,
+			traceId: e.traceId,
+			createdAt: s,
+			deliveredAt: null,
+			resendRequestedBy: null,
+			resendRequestedAt: null,
+			resendReason: null,
+			resendCount: 0
+		}, u = await e.store.insert(h, l);
+		if (e.afterCommit !== void 0 && e.nudge !== void 0) {
+			let t = e.nudge;
+			e.afterCommit(async () => {
+				t();
+			});
+		}
+		return u.id ?? l.id;
+	},
+	resend: async (r, i) => {
+		let a = (e.now ?? (() => /* @__PURE__ */ new Date()))(), o = (await e.store.query({
+			table: h,
+			predicate: n("id", r),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0];
+		if (o === void 0) throw Error(`outbox.resend: no entry "${r}"`);
+		let s = o.status;
+		if (s === "delivering") throw Error(`outbox.resend("${r}"): an attempt is in flight — retry once it settles`);
+		let c = o.attempts ?? 0, l = Math.max(1, Math.floor(i?.attempts ?? 1));
+		if (await e.store.updateMany("_voltro_outbox", {
+			status: "pending",
+			nextAttemptAt: a,
+			maxAttempts: c + l,
+			resendRequestedBy: e.subject.id ?? null,
+			resendRequestedAt: a,
+			resendReason: i?.reason ?? null,
+			resendCount: (o.resendCount ?? 0) + 1
+		}, { where: t(n("id", r), n("status", s), n("attempts", c), n("resendCount", o.resendCount ?? 0)) }) !== 1) throw Error(`outbox.resend("${r}"): entry changed while requesting another attempt; refresh its status`);
+		if (e.afterCommit !== void 0 && e.nudge !== void 0) {
+			let t = e.nudge;
+			e.afterCommit(async () => {
+				t();
+			});
+		} else e.nudge?.();
+	}
+}), w = (e) => Math.min(1e3 * 2 ** Math.max(0, e - 1), 3e5), T = 3e5, E = 50, D = (e, t) => e.length <= t ? e : `${e.slice(0, t)}… [clipped]`, O = (e) => {
+	if (e == null) return null;
+	let t = typeof e == "object" && !Array.isArray(e) ? e : { value: e }, n;
+	try {
+		n = JSON.stringify(t) ?? "";
+	} catch {
+		return { unserializable: !0 };
+	}
+	return n.length > 8192 ? {
+		truncated: !0,
+		preview: D(n, 8192)
+	} : t;
+}, k = async (e, t, i) => {
+	let a = t.outboxRow, o = a.id, s = a.resendRequestedBy ?? null;
+	try {
+		await e.insert(v, {
+			id: r(y, v),
+			outboxId: o,
+			effect: a.effect,
+			attempt: t.attempt,
+			trigger: a.resendRequestedAt == null ? "automatic" : "manual",
+			triggeredBy: s,
+			reason: a.resendReason ?? null,
+			outcome: t.outcome,
+			startedAt: t.startedAt,
+			finishedAt: t.finishedAt,
+			durationMs: Math.max(0, t.finishedAt.getTime() - t.startedAt.getTime()),
+			error: t.error === null ? null : D(t.error, 4e3),
+			response: O(t.response),
+			subjectId: a.subjectId ?? null,
+			tenantId: a.tenantId ?? null,
+			traceId: a.traceId ?? null
+		});
+	} catch (e) {
+		m.warn("outbox: could not record delivery attempt (delivery itself is unaffected)", {
+			outboxId: o,
+			attempt: t.attempt
+		}, e);
+		return;
+	}
+	if (!(t.attempt <= i)) try {
+		let t = await e.query({
+			table: v,
+			predicate: n("outboxId", o),
+			order: [{
+				column: "attempt",
+				direction: "asc"
+			}],
+			take: void 0,
+			skip: void 0,
+			projection: ["id"]
+		});
+		for (let n of t.slice(0, Math.max(0, t.length - i))) await e.delete(v, n.id);
+	} catch (e) {
+		m.warn("outbox: attempt-log trim failed; the log may exceed its cap", { outboxId: o }, e);
+	}
+}, A = async (e, t) => {
+	try {
+		let [r] = await e.query({
+			table: h,
+			predicate: n("status", "delivering"),
+			order: [{
+				column: "claimedAt",
+				direction: "asc"
+			}],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}), i = r?.claimedAt, a = i instanceof Date ? i.getTime() : typeof i == "string" || typeof i == "number" ? new Date(i).getTime() : NaN;
+		return Number.isFinite(a) ? a + t + 1 : void 0;
+	} catch (e) {
+		m.warn("outbox: could not read the oldest claim; a lost deliverer waits for the next pass", {}, e);
+		return;
+	}
+}, j = async (e, t) => {
+	try {
+		await e.store.update(h, t, {
+			status: "pending",
+			claimedBy: null,
+			claimedAt: null
+		});
+	} catch (e) {
+		m.warn("outbox: could not release a claim; the lease will reclaim it", { id: t }, e);
+	}
+}, M = async (r) => {
+	let i = (r.now ?? (() => /* @__PURE__ */ new Date()))(), o = i.getTime(), s = r.claimLeaseMs ?? 3e5;
+	try {
+		let e = await r.store.updateMany(h, {
+			status: "pending",
+			claimedBy: null,
+			claimedAt: null
+		}, { where: t(n("status", "delivering"), c("claimedAt", new Date(o - s))) });
+		e > 0 && m.warn("outbox: reclaimed rows whose deliverer stopped responding — they will be retried, so a handler that had already reached the remote will be called again", {
+			reclaimed: e,
+			leaseMs: s
+		});
+	} catch (e) {
+		m.warn("outbox: stuck-claim reclaim failed", {}, e);
+	}
+	let l = await r.store.query({
+		table: h,
+		predicate: t(n("status", "pending"), a("effect", [...r.handlers.keys()])),
+		order: [{
+			column: "nextAttemptAt",
+			direction: "asc"
+		}],
+		take: r.batchSize ?? 50,
+		skip: void 0,
+		projection: void 0
+	}), u = i.getTime(), d = (e) => {
+		let t = e.nextAttemptAt;
+		return t instanceof Date ? t.getTime() : new Date(t).getTime();
+	}, f = l.filter((e) => d(e) <= u), p;
+	for (let e of l) {
+		let t = d(e);
+		t <= u || Number.isNaN(t) || (p === void 0 || t < p) && (p = t);
+	}
+	let g = await A(r.store, s);
+	g !== void 0 && g > u && (p === void 0 || g < p) && (p = g);
+	let _ = [];
+	if (f.length > 0) {
+		let e = f.map((e) => e.id), i = new Date(o);
+		if (await r.store.updateMany("_voltro_outbox", {
+			status: "delivering",
+			claimedBy: r.claimedBy,
+			claimedAt: i
+		}, { where: t(n("status", "pending"), a("id", e)) }) === 0) return {
+			delivered: 0,
+			failed: 0,
+			dead: 0,
+			skipped: 0,
+			scanned: l.length,
+			...p === void 0 ? {} : { nextAttemptAt: p }
+		};
+		_ = await r.store.query({
+			table: h,
+			predicate: t(n("status", "delivering"), n("claimedBy", r.claimedBy), a("id", e)),
+			order: [{
+				column: "nextAttemptAt",
+				direction: "asc"
+			}],
+			take: void 0,
+			skip: void 0,
+			projection: void 0
+		});
+	}
+	let v = 0, y = 0, b = 0, x = 0;
+	for (let t of _) {
+		let n = t.id, a = t.effect, o = r.handlers.get(a);
+		if (o === void 0) {
+			x++, await j(r, n);
+			continue;
+		}
+		let s = t.attempts + 1, c = t.maxAttempts ?? S, l = /* @__PURE__ */ new Date(), u = r.attemptLogCap ?? 50;
+		try {
+			let i = {
+				outboxId: n,
+				idempotencyKey: t.idempotencyKey ?? null,
+				payload: t.payload ?? {},
+				attempt: s,
+				subjectId: t.subjectId ?? null,
+				tenantId: t.tenantId ?? null,
+				traceId: t.traceId ?? null
+			}, a = o.handler(i), c = e.isEffect(a) ? a : await a, d = e.isEffect(c) ? await (r.runEffect ? r.runEffect(c, i) : e.runPromise(c)) : c;
+			await k(r.store, {
+				outboxRow: t,
+				attempt: s,
+				outcome: "delivered",
+				startedAt: l,
+				finishedAt: /* @__PURE__ */ new Date(),
+				error: null,
+				response: d
+			}, u), await r.store.update(h, n, {
+				status: "delivered",
+				attempts: s,
+				deliveredAt: /* @__PURE__ */ new Date(),
+				lastError: null,
+				claimedBy: null,
+				claimedAt: null,
+				resendRequestedBy: null,
+				resendRequestedAt: null,
+				resendReason: null
+			}), v++;
+		} catch (e) {
+			let o = e instanceof Error ? e.message : String(e), d = s >= c;
+			await k(r.store, {
+				outboxRow: t,
+				attempt: s,
+				outcome: d ? "dead" : "failed",
+				startedAt: l,
+				finishedAt: /* @__PURE__ */ new Date(),
+				error: o,
+				response: null
+			}, u), await r.store.update(h, n, {
+				status: d ? "dead" : "pending",
+				attempts: s,
+				lastError: o,
+				nextAttemptAt: new Date(i.getTime() + w(s)),
+				claimedBy: null,
+				claimedAt: null,
+				resendRequestedBy: null,
+				resendRequestedAt: null,
+				resendReason: null
+			}), d ? (b++, m.error("outbox effect dead-lettered after exhausting attempts", {
+				id: n,
+				effect: a,
+				attempts: s,
+				maxAttempts: c
+			}, e)) : (y++, m.warn("outbox delivery failed; will retry", {
+				id: n,
+				effect: a,
+				attempt: s,
+				maxAttempts: c,
+				retryInMs: w(s)
+			}));
+		}
+	}
+	return {
+		delivered: v,
+		failed: y,
+		dead: b,
+		skipped: x,
+		scanned: l.length,
+		...p === void 0 ? {} : { nextAttemptAt: p }
+	};
+};
+//#endregion
+export { T as DEFAULT_OUTBOX_CLAIM_LEASE_MS, v as OUTBOX_ATTEMPTS_TABLE, E as OUTBOX_ATTEMPT_LOG_CAP, h as OUTBOX_TABLE, w as backoffMs, x as defineOutboxHandler, M as drainOutbox, C as makeOutboxFacade, b as outboxAttemptsTable, _ as outboxTable };

package/dist/pluginRefRules.js

@@ -0,0 +1,65 @@
+import { and as e, eq as t } from "@voltro/database";
+//#region src/pluginRefRules.ts
+var n = (e) => e.old ?? e.new ?? {}, r = (e) => String(n(e).id ?? ""), i = (e) => {
+	let t = n(e).tenantId;
+	return typeof t == "string" ? t : null;
+}, a = (e) => e.op === "update" && (e.old?.deletedAt ?? null) === null && (e.new?.deletedAt ?? null) !== null, o = (e, t) => {
+	let n = a(t);
+	return t.op !== "delete" && !n ? [] : e.filter((e) => e.targetTable === t.table && e.policy !== "keep" && (n ? e.onSoftDelete : e.onHardDelete !== !1));
+}, s = (e) => {
+	let t = [], n = [];
+	for (let r of e) for (let [e, i] of Object.entries(r.fields ?? {})) {
+		if (i.refOnSoftDelete === void 0 || i.type !== "reference" || i.references === void 0) continue;
+		let a;
+		try {
+			a = i.references()?.tableName;
+		} catch {
+			a = void 0;
+		}
+		a !== void 0 && (i.refOnSoftDelete === "cascade" && r.softDeletable !== !0 ? n.push(`${r.name}.${e} → ${a}`) : t.push({
+			table: r.name,
+			column: e,
+			targetTable: a,
+			policy: i.refOnSoftDelete === "cascade" ? "delete" : "null",
+			onSoftDelete: !0,
+			onHardDelete: !1
+		}));
+	}
+	if (n.length > 0) throw Error(`reference(…, { onSoftDelete: 'cascade' }) on a table without softDelete(): ${n.join(", ")}.\n  A cascade on a SOFT delete must soft-delete the children, so their table needs \`.with(softDelete())\` —
+  otherwise the runtime would hard-delete them, and restoring the parent would restore nothing.
+  Add the mixin, or use { onSoftDelete: 'setNull' } on a nullable column.`);
+	return t;
+}, c = async (n, a, s) => {
+	let c = o(a, s);
+	if (c.length === 0) return [];
+	let l = r(s), u = i(s), d = [];
+	for (let r of c) {
+		let i = u === null ? t(r.column, l) : e(t(r.column, l), t("tenantId", u)), a = r.policy === "delete" ? await n.deleteMany(r.table, { where: i }) : await n.updateMany(r.table, { [r.column]: null }, { where: i });
+		d.push({
+			rule: r,
+			affected: a
+		});
+	}
+	return d;
+}, l = (e, t) => {
+	let n = [];
+	for (let r of e) for (let e of r.appliedPluginRefs ?? []) {
+		let i = e.column, a;
+		try {
+			a = e.target()?.tableName;
+		} catch {
+			a = void 0;
+		}
+		if (a === void 0 || !t.has(a)) throw Error(`pluginRef: ${r.name}.${i} points at ${a ?? "an unresolvable table"}, which no installed plugin registers. A declared orphan rule against an absent table would look enforced and never fire — install the plugin that owns it, or drop the column.`);
+		n.push({
+			table: r.name,
+			column: i,
+			targetTable: a,
+			policy: e.orphanPolicy,
+			onSoftDelete: e.onSoftDelete
+		});
+	}
+	return n.filter((e) => e.policy !== "keep");
+};
+//#endregion
+export { c as applyPluginRefRules, l as collectPluginRefRules, s as collectReferenceSoftDeleteRules, a as isSoftDelete, o as rulesFor };

package/dist/policyGuardResolver.js

@@ -0,0 +1,55 @@
+import { can as e, getResourcePolicy as t } from "./rebac.js";
+import { currentRequestLoader as n } from "./requestLoader.js";
+import { Effect as r } from "effect";
+import { setPolicyGuardResolver as i } from "@voltro/protocol";
+import { createLogger as a } from "@voltro/logger";
+//#region src/policyGuardResolver.ts
+var o = a({ scope: "voltro:policy" }), s, c = (e) => {
+	s = e;
+}, l = () => s, u = (e) => s === void 0 && (s = e, !0), d = () => {
+	i((i) => r.gen(function* () {
+		let a = t(i.resourceType);
+		if (a === void 0) return o.warn("policy guard denied — no resource policy registered for this type", {
+			resourceType: i.resourceType,
+			action: i.action
+		}), !1;
+		let c = s;
+		if (c === void 0) return o.warn("policy guard denied — no tuple source registered (call setTupleSource at boot)", {
+			resourceType: i.resourceType,
+			action: i.action
+		}), !1;
+		let l = yield* r.tryPromise({
+			try: async () => c({
+				subjectId: i.subject.id,
+				subject: i.subject,
+				resourceType: i.resourceType,
+				resourceId: i.resourceId,
+				load: n()
+			}),
+			catch: (e) => e
+		}).pipe(r.catch((e) => (o.error("policy guard denied — tuple source failed", {
+			resourceType: i.resourceType,
+			resourceId: i.resourceId
+		}, e), r.succeed([]))));
+		if (l === "missing") return "missing";
+		if (!Array.isArray(l)) return o.error("policy guard denied — tuple source returned neither tuples nor 'missing'", {
+			resourceType: i.resourceType,
+			resourceId: i.resourceId
+		}), !1;
+		let u = i.subject;
+		return e({
+			id: i.subject.id,
+			tenantId: u.tenantId ?? null,
+			...u.scopes === void 0 ? {} : { scopes: u.scopes }
+		}, i.action, {
+			type: i.resourceType,
+			id: i.resourceId,
+			tenantId: u.tenantId ?? null
+		}, {
+			policy: a,
+			tuples: l
+		});
+	}));
+};
+//#endregion
+export { l as getTupleSource, d as installPolicyGuardResolver, u as registerDefaultTupleSource, c as setTupleSource };

package/dist/preview.js

@@ -0,0 +1,62 @@
+//#region src/preview.ts
+var e = (e) => {
+	let t = e.new?.id;
+	if (typeof t == "string") return t;
+	let n = e.old?.id;
+	return typeof n == "string" ? n : void 0;
+}, t = (t) => {
+	let n = {};
+	if (t.op === "insert") for (let [e, r] of Object.entries(t.new ?? {})) n[e] = {
+		from: void 0,
+		to: r
+	};
+	else if (t.op === "delete") for (let [e, r] of Object.entries(t.old ?? {})) n[e] = {
+		from: r,
+		to: void 0
+	};
+	else {
+		let e = t.old ?? {}, r = t.new ?? {};
+		for (let t of /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(r)])) Object.is(e[t], r[t]) || (n[t] = {
+			from: e[t],
+			to: r[t]
+		});
+	}
+	return {
+		table: t.table,
+		op: t.op,
+		id: e(t),
+		fields: n
+	};
+}, n = (e) => {
+	let n = e.map(t), r = {
+		inserts: 0,
+		updates: 0,
+		deletes: 0
+	};
+	for (let e = 0; e < n.length; e++) {
+		if (!(e in n)) continue;
+		let t = n[e];
+		t.op === "insert" ? r.inserts += 1 : t.op === "update" ? r.updates += 1 : t.op === "delete" && (r.deletes += 1);
+	}
+	return {
+		rows: n,
+		summary: r
+	};
+}, r = class extends Error {
+	constructor() {
+		super("voltro:preview-rollback"), this.name = "PreviewRollback";
+	}
+}, i = async (e, t) => {
+	let n, i = !1;
+	try {
+		await e.transactional(async (e) => {
+			throw n = await t(e), i = !0, new r();
+		});
+	} catch (e) {
+		if (!(e instanceof r)) throw e;
+	}
+	if (!i) throw Error("preview: handler did not complete");
+	return n;
+};
+//#endregion
+export { n as buildPreview, t as diffChange, i as previewInRollback };

package/dist/projectedRows.js

@@ -0,0 +1,12 @@
+//#region src/projectedRows.ts
+var e = (e, t) => {
+	let n = [], r = e.length;
+	for (let i = 0; i < r; i += 1) {
+		if (!(i in e)) continue;
+		let r = t(e[i]);
+		r !== null && n.push(r);
+	}
+	return n;
+};
+//#endregion
+export { e as collectProjectedRows };

package/dist/provenance.js

@@ -0,0 +1,63 @@
+//#region src/provenance.ts
+var e = (e) => e instanceof Date ? e.toISOString() : typeof e == "string" && e.length > 0 ? e : null, t = (e) => typeof e == "string" && e.length > 0 ? e : null, n = [
+	"updatedAt",
+	"createdAt",
+	"updatedBy",
+	"createdBy"
+], r = (e) => n.some((t) => t in e), i = (n, i, a) => {
+	let o = {
+		table: i.table,
+		id: i.id,
+		...i.column === void 0 ? {} : { column: i.column },
+		...a?.derived ? { derived: !0 } : {}
+	};
+	if (!n) return {
+		...o,
+		value: void 0,
+		lastWrite: null,
+		attribution: "none",
+		found: !1
+	};
+	let s = i.column === void 0 ? void 0 : n[i.column];
+	if (!r(n)) return {
+		...o,
+		value: s,
+		lastWrite: null,
+		attribution: "none",
+		found: !0
+	};
+	let c = t(n.updatedBy) ?? t(n.createdBy), l = e(n.updatedAt) ?? e(n.createdAt);
+	return {
+		...o,
+		value: s,
+		lastWrite: {
+			actor: { id: c },
+			at: l,
+			...a?.traceId === void 0 ? {} : { traceId: a.traceId }
+		},
+		attribution: "audit",
+		found: !0
+	};
+}, a = (n, r) => {
+	let i = n.map((n) => {
+		let i = n.newValue ?? n.value, a = r.column !== void 0 && i && typeof i == "object" ? i[r.column] : n.newValue ?? n.value;
+		return {
+			actor: { id: t(n.actor) ?? t(n.changedBy) },
+			at: e(n.at) ?? e(n.changedAt),
+			...n.traceId === void 0 ? {} : { traceId: n.traceId },
+			value: a
+		};
+	}), a = i.length > 0 ? i[i.length - 1] : null;
+	return {
+		table: r.table,
+		id: r.id,
+		...r.column === void 0 ? {} : { column: r.column },
+		value: a?.value,
+		lastWrite: a,
+		attribution: a ? "audit" : "none",
+		history: i,
+		found: i.length > 0
+	};
+};
+//#endregion
+export { a as historyProvenance, i as lastWriteProvenance };

package/dist/rangeIndex.js

@@ -0,0 +1,89 @@
+//#region src/rangeIndex.ts
+var e = (e) => e?.height ?? 0, t = (t) => (t.height = 1 + Math.max(e(t.left), e(t.right)), t), n = (e) => {
+	let n = e.left;
+	return e.left = n.right, n.right = t(e), t(n);
+}, r = (e) => {
+	let n = e.right;
+	return e.right = n.left, n.left = t(e), t(n);
+}, i = (i) => (t(i), e(i.left) - e(i.right) > 1 ? (e(i.left.left) < e(i.left.right) && (i.left = r(i.left)), n(i)) : e(i.right) - e(i.left) > 1 ? (e(i.right.right) < e(i.right.left) && (i.right = n(i.right)), r(i)) : i), a = (e) => typeof e == "string" || typeof e == "boolean" || typeof e == "number" && !Number.isNaN(e), o = (e, t) => e < t, s = (e, t, n) => e ? (t === e.value ? e.members.add(n) : o(t, e.value) ? e.left = s(e.left, t, n) : e.right = s(e.right, t, n), i(e)) : {
+	value: t,
+	members: /* @__PURE__ */ new Set([n]),
+	height: 1,
+	left: void 0,
+	right: void 0
+}, c = (e, t, n) => {
+	if (e) {
+		if (t === e.value) {
+			if (n !== void 0 && e.members.delete(n), n !== void 0 && e.members.size > 0) return e;
+			if (!e.left) return e.right;
+			if (!e.right) return e.left;
+			let t = e.right;
+			for (; t.left;) t = t.left;
+			e.value = t.value, e.members = t.members, e.right = c(e.right, t.value, void 0);
+		} else o(t, e.value) ? e.left = c(e.left, t, n) : e.right = c(e.right, t, n);
+		return i(e);
+	}
+}, l = class {
+	members = /* @__PURE__ */ new Map();
+	roots = /* @__PURE__ */ new Map();
+	fallback = /* @__PURE__ */ new Map();
+	get size() {
+		return this.members.size;
+	}
+	keys() {
+		return this.members.keys();
+	}
+	add(e, t) {
+		let n = this.members.get(e);
+		if (n ? n.push(t) : this.members.set(e, [t]), a(t)) this.roots.set(typeof t, s(this.roots.get(typeof t), t, e));
+		else {
+			let n = this.fallback.get(e);
+			n ? n.push(t) : this.fallback.set(e, [t]);
+		}
+	}
+	delete(e) {
+		for (let t of this.members.get(e) ?? []) {
+			if (!a(t)) continue;
+			let n = c(this.roots.get(typeof t), t, e);
+			n ? this.roots.set(typeof t, n) : this.roots.delete(typeof t);
+		}
+		this.members.delete(e), this.fallback.delete(e);
+	}
+	numericExtreme(e) {
+		let t = this.roots.get("number");
+		if (t === void 0) return;
+		let n = t;
+		for (;;) {
+			let t = e === "min" ? n.left : n.right;
+			if (t === void 0) return n.value;
+			n = t;
+		}
+	}
+	candidates(e, t, n) {
+		let r = /* @__PURE__ */ new Set();
+		if (!a(e)) {
+			for (let [e, t] of this.members) t.some(n) && r.add(e);
+			return r;
+		}
+		let i = (e) => {
+			if (e) {
+				i(e.left);
+				for (let t of e.members) r.add(t);
+				i(e.right);
+			}
+		}, s = t === "gt" || t === "gte", c = t === "gte" || t === "lte", l = (t) => {
+			if (t) {
+				if ((s ? o(t.value, e) : o(e, t.value)) || c && e === t.value) {
+					i(s ? t.left : t.right);
+					for (let e of t.members) r.add(e);
+					l(s ? t.right : t.left);
+				} else l(s ? t.left : t.right);
+			}
+		};
+		l(this.roots.get(typeof e));
+		for (let [e, t] of this.fallback) t.some(n) && r.add(e);
+		return r;
+	}
+};
+//#endregion
+export { l as RangeIndex };