@voltro/runtime 0.84.0 → 0.86.0

package/dist/expectationEvaluator.js

@@ -0,0 +1,308 @@
+import { AggregateMaintainer as e } from "./aggregateIvm.js";
+import { collectProjectedRows as t } from "./projectedRows.js";
+//#region src/expectationEvaluator.ts
+var n = (e) => {
+	if (e instanceof Date) return e.getTime();
+	if (typeof e == "number" && Number.isFinite(e)) return e;
+	if (typeof e == "string" && e.length > 0) {
+		let t = Date.parse(e);
+		return Number.isNaN(t) ? null : t;
+	}
+	return null;
+}, r = class {
+	maxAgeMs;
+	timeDependent = !0;
+	maintainer;
+	column;
+	constructor(t, n) {
+		this.maxAgeMs = n, this.column = t, this.maintainer = new e({
+			op: "max",
+			column: t
+		});
+	}
+	project(e) {
+		if (e == null) return null;
+		let t = n(e[this.column]);
+		return t === null ? null : {
+			...e,
+			[this.column]: t
+		};
+	}
+	seed(e) {
+		this.maintainer.seed(t(e, (e) => this.project(e)));
+	}
+	apply(e) {
+		let t = this.project(e.old), n = this.project(e.new);
+		return t === null && n === null ? [] : t === null ? this.maintainer.applyChange({
+			op: "insert",
+			old: null,
+			new: n
+		}) : n === null ? this.maintainer.applyChange({
+			op: "delete",
+			old: t,
+			new: null
+		}) : this.maintainer.applyChange({
+			op: "update",
+			old: t,
+			new: n
+		});
+	}
+	resolveRescan(e, n) {
+		this.maintainer.resolveRescan(e, t(n, (e) => this.project(e)));
+	}
+	read(e) {
+		let t = this.maintainer.materialize()[0]?.value ?? null;
+		if (t === null) return {
+			metric: null,
+			threshold: this.maxAgeMs,
+			violated: !1
+		};
+		let n = e - t;
+		return {
+			metric: n,
+			threshold: this.maxAgeMs,
+			violated: n > this.maxAgeMs
+		};
+	}
+}, i = class {
+	matches;
+	reduce;
+	timeDependent = !1;
+	total = 0;
+	matching = 0;
+	constructor(e, t) {
+		this.matches = e, this.reduce = t;
+	}
+	seed(e) {
+		this.total = e.length, this.matching = e.reduce((e, t) => e + +!!this.matches(t), 0);
+	}
+	add(e) {
+		e != null && (this.total += 1, this.matches(e) && (this.matching += 1));
+	}
+	remove(e) {
+		e != null && (--this.total, this.matches(e) && --this.matching);
+	}
+	apply(e) {
+		return e.op === "insert" ? this.add(e.new) : e.op === "delete" ? this.remove(e.old) : (this.remove(e.old), this.add(e.new)), this.total < 0 && (this.total = 0), this.matching < 0 && (this.matching = 0), this.matching > this.total && (this.matching = this.total), [];
+	}
+	resolveRescan() {}
+	read() {
+		return this.reduce(this.total, this.matching);
+	}
+}, a = (e) => e == null, o = (e, t, n) => {
+	if (a(e)) return !1;
+	let r = Number(e);
+	return Number.isNaN(r) ? !1 : t !== void 0 && r < t || n !== void 0 && r > n;
+}, s = (e) => {
+	switch (e.kind) {
+		case "freshness": return new r(e.column, e.maxAgeMs);
+		case "nullRate": {
+			let t = e.column, n = e.maxRate;
+			return new i((e) => a(e[t]), (e, t) => {
+				let r = e > 0 ? t / e : 0;
+				return {
+					metric: r,
+					threshold: n,
+					violated: r > n
+				};
+			});
+		}
+		case "rowCount": {
+			let { min: t, max: n } = e;
+			return new i(() => !1, (e) => ({
+				metric: e,
+				threshold: n ?? t ?? null,
+				violated: t !== void 0 && e < t || n !== void 0 && e > n
+			}));
+		}
+		case "valueBounds": {
+			let { column: t, min: n, max: r, maxViolationRate: a } = e;
+			return new i((e) => o(e[t], n, r), (e, t) => {
+				if (a !== void 0) {
+					let n = e > 0 ? t / e : 0;
+					return {
+						metric: n,
+						threshold: a,
+						violated: n > a
+					};
+				}
+				return {
+					metric: t,
+					threshold: 0,
+					violated: t > 0
+				};
+			});
+		}
+	}
+}, c = (e) => ({
+	table: e.table,
+	op: e.op,
+	traceId: e.traceId ?? null,
+	subjectId: e.subjectId ?? null,
+	procedure: e.procedure ?? null
+}), l = (e, t) => !t || e.metric === null ? "unknown" : e.violated ? "violated" : "holding", u = class {
+	def;
+	deps;
+	engine;
+	now;
+	seeded = !1;
+	status = "unknown";
+	metric = null;
+	threshold = null;
+	since = null;
+	lastEvaluatedAt = null;
+	lastCause = null;
+	constructor(e, t) {
+		this.def = e, this.deps = t, this.engine = s(e.invariant), this.now = t.now ?? Date.now, this.threshold = null;
+	}
+	get timeDependent() {
+		return this.engine.timeDependent;
+	}
+	inScope(e) {
+		if (e == null) return !1;
+		let t = this.def.on.where;
+		return t === void 0 || t(e);
+	}
+	async seed() {
+		let e = (await this.deps.queryBase()).filter((e) => this.inScope(e));
+		this.engine.seed(e), this.seeded = !0;
+		let t = this.engine.read(this.now());
+		this.commitReading(t, !1, null);
+	}
+	async applyChange(e) {
+		if (e.table !== this.def.on.table) return null;
+		let t = e.op !== "insert" && e.old == null, n = e.op !== "delete" && e.new == null;
+		if (t || n) {
+			let t = (await this.deps.queryBase()).filter((e) => this.inScope(e));
+			return this.engine.seed(t), this.seeded = !0, this.commitReading(this.engine.read(this.now()), !0, c(e));
+		}
+		let r = this.inScope(e.old), i = this.inScope(e.new);
+		if (!r && !i) return null;
+		let a = {
+			op: e.op,
+			old: r ? e.old : null,
+			new: i ? e.new : null
+		}, o = this.engine.apply(a);
+		if (o.length > 0) {
+			let e = (await this.deps.queryBase()).filter((e) => this.inScope(e));
+			this.engine.resolveRescan(o, e);
+		}
+		return this.commitReading(this.engine.read(this.now()), !0, c(e));
+	}
+	tick() {
+		return this.seeded ? this.commitReading(this.engine.read(this.now()), !0, null) : null;
+	}
+	commitReading(e, t, n) {
+		let r = this.status, i = l(e, this.seeded);
+		if (this.metric = e.metric, this.threshold = e.threshold, this.lastEvaluatedAt = new Date(this.now()), i !== r) {
+			if (this.status = i, this.since = this.lastEvaluatedAt, i === "violated" && (this.lastCause = n), t && i === "violated" && r !== "violated") return {
+				kind: "violated",
+				state: this.state(),
+				cause: n
+			};
+			if (t && r === "violated" && i !== "violated") return {
+				kind: "recovered",
+				state: this.state(),
+				cause: null
+			};
+		}
+		return null;
+	}
+	state() {
+		return {
+			name: this.def.name,
+			table: this.def.on.table,
+			invariant: this.def.invariant.kind,
+			rule: { ...this.def.invariant },
+			severity: this.def.severity,
+			status: this.status,
+			metric: this.metric,
+			threshold: this.threshold,
+			since: this.since,
+			lastEvaluatedAt: this.lastEvaluatedAt,
+			lastCause: this.lastCause,
+			...this.def.description === void 0 ? {} : { description: this.def.description }
+		};
+	}
+}, d = (e) => {
+	let t = e.now ?? Date.now, n = e.log, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), a = (e) => {
+		for (let t of r) try {
+			t(e);
+		} catch (t) {
+			n.warn("expectation: transition listener threw", { name: e.state.name }, t);
+		}
+	}, o = (t) => async () => await e.store.query({
+		table: t,
+		predicate: void 0,
+		order: [],
+		take: void 0,
+		skip: void 0,
+		projection: void 0
+	}), s = /* @__PURE__ */ new Map(), c = !1;
+	for (let { definition: r } of e.discovered) {
+		if (i.has(r.name)) throw Error(`expectation: duplicate name '${r.name}' — names must be unique across all expectations`);
+		let e = new u(r, {
+			queryBase: o(r.on.table),
+			now: t,
+			...n === void 0 ? {} : { log: n }
+		});
+		i.set(r.name, e);
+		let a = s.get(r.on.table) ?? [];
+		a.push(e), s.set(r.on.table, a), e.timeDependent && (c = !0);
+	}
+	(async () => {
+		for (let e of i.values()) try {
+			await e.seed();
+		} catch (e) {
+			n.warn("expectation: seed failed — will retry on reconcile", { err: String(e) });
+		}
+	})();
+	let l = e.store.onChange((e) => {
+		let t = s.get(e.table);
+		t !== void 0 && t.length !== 0 && (async () => {
+			for (let r of t) try {
+				let t = await r.applyChange(e);
+				t !== null && a(t);
+			} catch (e) {
+				n.warn("expectation: delta apply failed — reconcile will heal", { err: String(e) });
+			}
+		})();
+	}), d = () => {
+		if (c) for (let e of i.values()) {
+			if (!e.timeDependent) continue;
+			let t = e.tick();
+			t !== null && a(t);
+		}
+	}, f = null;
+	c && (f = setInterval(d, e.tickIntervalMs ?? 3e4), f.unref?.());
+	let p = setInterval(() => {
+		(async () => {
+			for (let e of i.values()) try {
+				await e.seed();
+			} catch {}
+		})();
+	}, e.reconcileIntervalMs ?? 3e5);
+	p.unref?.();
+	let m = (e) => {
+		let t = e ? [] : Array(i.size), n = 0;
+		return i.forEach((r) => {
+			let i = r.state();
+			(!e || i.status === "violated") && (t[n++] = i);
+		}), t;
+	};
+	return {
+		registry: {
+			snapshot: () => m(!1),
+			get: (e) => i.get(e)?.state() ?? null,
+			violations: () => m(!0),
+			subscribe: (e) => (r.add(e), () => r.delete(e))
+		},
+		detach: () => {
+			l(), f !== null && clearInterval(f), clearInterval(p), r.clear();
+		},
+		registered: [...i.keys()],
+		runTick: d
+	};
+};
+//#endregion
+export { u as ExpectationEvaluator, d as attachExpectations };

package/dist/experiment.js

@@ -0,0 +1,96 @@
+import { Context as e, Effect as t } from "effect";
+//#region src/experiment.ts
+var n = "holdout", r = (e, t) => /* @__PURE__ */ Error(`defineExperiment(${JSON.stringify(e)}): ${t}`), i = (e) => {
+	if (e == null) return null;
+	if (typeof e == "number") return Number.isFinite(e) ? String(e) : null;
+	let t = String(e);
+	return t.length > 0 ? t : null;
+}, a = (e) => {
+	let t = e.name;
+	if (typeof t != "string" || t.length === 0) throw Error("defineExperiment: a non-empty `name` is required");
+	if (e.on === void 0 || typeof e.on.table != "string" || e.on.table.length === 0) throw r(t, "on.table is required — the table whose writes drive the experiment");
+	if (e.on.where !== void 0 && typeof e.on.where != "function") throw r(t, "on.where, when present, must be a predicate function");
+	let a = e.subject !== void 0, o = e.variantFrom !== void 0;
+	if (a && o) throw r(t, "declare `subject` OR `variantFrom`, not both — they are two answers to \"which arm is this row in?\"");
+	let s = null, c = null;
+	if (o) {
+		if (typeof e.variantFrom == "string") {
+			if (e.variantFrom.length === 0) throw r(t, "variantFrom, when a column name, must be non-empty");
+			let n = e.variantFrom;
+			c = (e) => i(e[n]);
+		} else if (typeof e.variantFrom == "function") {
+			let t = e.variantFrom;
+			c = (e) => i(t(e));
+		} else throw r(t, "variantFrom must be a column name or a (row) => variantName function");
+	} else if (typeof e.subject == "string") {
+		if (e.subject.length === 0) throw r(t, "subject, when a column name, must be non-empty");
+		let n = e.subject;
+		s = (e) => i(e[n]);
+	} else if (typeof e.subject == "function") {
+		let t = e.subject;
+		s = (e) => i(t(e));
+	} else throw r(t, "subject is required — a column name or a (row) => key function (or use `variantFrom` to measure an arm something else assigned)");
+	if (!Array.isArray(e.variants) || e.variants.length < 2) throw r(t, "at least two variants are required (a control + one treatment)");
+	let l = /* @__PURE__ */ new Set(), u = [];
+	for (let n of e.variants) {
+		if (typeof n != "object" || !n || typeof n.name != "string" || n.name.length === 0) throw r(t, "each variant needs a non-empty `name`");
+		if (l.has(n.name)) throw r(t, `duplicate variant name ${JSON.stringify(n.name)}`);
+		l.add(n.name);
+		let e = n.weight ?? 1;
+		if (!(typeof e == "number" && Number.isFinite(e) && e > 0)) throw r(t, `variant ${JSON.stringify(n.name)} weight must be a positive, finite number`);
+		u.push({
+			name: n.name,
+			weight: e
+		});
+	}
+	let d = 0;
+	if (e.holdout !== void 0) {
+		if (c !== null && e.holdout > 0) throw r(t, `holdout is meaningless with \`variantFrom\` — a holdout is carved out AT ASSIGNMENT, and this experiment does not assign. Declare the holdout arm on whatever does (a flag variant named "${n}", say) and list it in \`variants\`.`);
+		if (!(typeof e.holdout == "number" && e.holdout >= 0 && e.holdout < 1)) throw r(t, "holdout, when present, must be a fraction in [0, 1)");
+		if (d = e.holdout, d > 0 && l.has("holdout")) throw r(t, `a variant may not be named ${JSON.stringify(n)} when holdout > 0 (reserved)`);
+	}
+	let f = e.metric;
+	if (f === void 0 || typeof f.kind != "string") throw r(t, "metric is required");
+	switch (f.kind) {
+		case "count": break;
+		case "sum":
+		case "avg":
+			if (typeof f.column != "string" || f.column.length === 0) throw r(t, `${f.kind} metric requires a numeric \`column\``);
+			break;
+		case "conversionRate":
+			if (typeof f.column != "string" || f.column.length === 0) throw r(t, "conversionRate metric requires a `column`");
+			break;
+		default: throw r(t, `unknown metric kind ${JSON.stringify(f.kind)}`);
+	}
+	let p = e.baseline ?? u[0].name;
+	if (!l.has(p)) throw r(t, `baseline ${JSON.stringify(p)} is not one of the declared variants`);
+	return {
+		_voltroExperiment: !0,
+		name: t,
+		on: e.on.where === void 0 ? { table: e.on.table } : {
+			table: e.on.table,
+			where: e.on.where
+		},
+		subject: s,
+		variantFrom: c,
+		variants: u,
+		holdout: d,
+		metric: f,
+		baseline: p,
+		...e.description === void 0 ? {} : { description: e.description }
+	};
+}, o = (e) => typeof e == "object" && !!e && e._voltroExperiment === !0, s = (e) => {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
+	return (t >>> 0) / 4294967296;
+}, c = (e, t) => {
+	let r = s(`${e.name}\u0000${t}`);
+	if (e.holdout > 0 && r < e.holdout) return n;
+	let i = e.holdout > 0 ? (r - e.holdout) / (1 - e.holdout) : r, a = e.variants.reduce((e, t) => e + t.weight, 0), o = 0;
+	for (let t of e.variants) if (o += t.weight / a, i < o) return t.name;
+	return e.variants[e.variants.length - 1].name;
+}, l = (e) => e.holdout > 0 ? [...e.variants.map((e) => e.name), n] : e.variants.map((e) => e.name), u = class extends e.Service()("@voltro/ExperimentRegistry") {}, d = (e) => t.gen(function* () {
+	return (yield* u).get(e.name);
+});
+//#endregion
+export { u as ExperimentRegistry, n as HOLDOUT_VARIANT, c as assignVariant, a as defineExperiment, s as hashUnitInterval, o as isExperimentDefinition, l as resultVariantNames, d as useExperiment };

package/dist/experimentEvaluator.js

@@ -0,0 +1,245 @@
+import { AggregateMaintainer as e } from "./aggregateIvm.js";
+import { collectProjectedRows as t } from "./projectedRows.js";
+import { assignVariant as n, resultVariantNames as r } from "./experiment.js";
+//#region src/experimentEvaluator.ts
+var i = "__voltro_variant", a = "__voltro_metric", o = class {
+	project;
+	maintainer;
+	constructor(t, n) {
+		this.project = n, this.maintainer = new e(t);
+	}
+	seed(e) {
+		this.maintainer.seed(t(e, (e) => this.project(e)));
+	}
+	apply(e) {
+		let t = e.old ? this.project(e.old) : null, n = e.new ? this.project(e.new) : null;
+		(t !== null || n !== null) && (t === null ? this.maintainer.applyChange({
+			op: "insert",
+			old: null,
+			new: n
+		}) : n === null ? this.maintainer.applyChange({
+			op: "delete",
+			old: t,
+			new: null
+		}) : this.maintainer.applyChange({
+			op: "update",
+			old: t,
+			new: n
+		}));
+	}
+	byVariant() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of this.maintainer.materialize()) {
+			let n = t.group[i];
+			typeof n == "string" && e.set(n, t.value);
+		}
+		return e;
+	}
+}, s = (e) => typeof e == "number" && Number.isFinite(e), c = (e) => {
+	if (s(e)) return e;
+	let t = Number(e);
+	return Number.isFinite(t) ? t : null;
+}, l = (e, t) => new o(e.kind === "count" ? {
+	op: "count",
+	groupBy: [i]
+} : {
+	op: e.kind === "sum" ? "sum" : "avg",
+	column: a,
+	groupBy: [i]
+}, (n) => {
+	let r = t(n);
+	if (r === null) return null;
+	switch (e.kind) {
+		case "count": return { [i]: r };
+		case "sum":
+		case "avg": {
+			let t = c(n[e.column]);
+			return t === null ? null : {
+				[i]: r,
+				[a]: t
+			};
+		}
+		case "conversionRate": {
+			let t = n[e.column], o = e.equals === void 0 ? !!t : t === e.equals;
+			return {
+				[i]: r,
+				[a]: +!!o
+			};
+		}
+	}
+}), u = (e) => new o({
+	op: "count",
+	groupBy: [i]
+}, (t) => {
+	let n = e(t);
+	return n === null ? null : { [i]: n };
+}), d = (e) => ({
+	table: e.table,
+	op: e.op,
+	traceId: e.traceId ?? null,
+	subjectId: e.subjectId ?? null,
+	procedure: e.procedure ?? null
+}), f = class {
+	def;
+	deps;
+	exposure;
+	metric;
+	metricIsCount;
+	now;
+	seeded = !1;
+	lastUpdatedAt = null;
+	declaredVariants;
+	constructor(e, t) {
+		this.def = e, this.deps = t, this.now = t.now ?? Date.now, this.declaredVariants = new Set(r(e));
+		let n = (e) => this.variantOf(e);
+		this.exposure = u(n), this.metricIsCount = e.metric.kind === "count", this.metric = this.metricIsCount ? this.exposure : l(e.metric, n);
+	}
+	variantOf(e) {
+		if (e == null) return null;
+		let t = this.def.on.where;
+		if (t !== void 0 && !t(e)) return null;
+		if (this.def.variantFrom !== null) {
+			let t = this.def.variantFrom(e);
+			return t === null ? null : this.declaredVariants.has(t) ? t : null;
+		}
+		if (this.def.subject === null) return null;
+		let r = this.def.subject(e);
+		return r === null ? null : n(this.def, r);
+	}
+	inScope(e) {
+		return this.variantOf(e) !== null;
+	}
+	async seed() {
+		let e = await this.deps.queryBase();
+		this.exposure.seed(e), this.metricIsCount || this.metric.seed(e), this.seeded = !0, this.lastUpdatedAt = new Date(this.now());
+	}
+	applyChange(e) {
+		if (e.table !== this.def.on.table) return null;
+		let t = this.inScope(e.old), n = this.inScope(e.new);
+		if (!t && !n) return null;
+		let r = {
+			op: e.op,
+			old: t ? e.old : null,
+			new: n ? e.new : null
+		};
+		return this.exposure.apply(r), this.metricIsCount || this.metric.apply(r), this.lastUpdatedAt = new Date(this.now()), {
+			result: this.result(),
+			cause: d(e)
+		};
+	}
+	result() {
+		let e = this.exposure.byVariant(), t = this.metricIsCount ? e : this.metric.byVariant(), n = this.def.baseline, i = this.metricValueFor(n, t, e), a = 0, o = [];
+		for (let s of r(this.def)) {
+			let r = e.get(s) ?? 0;
+			a += r;
+			let c = this.metricValueFor(s, t, e), l = s === n, u = l || c === null || i === null ? null : c - i, d = l || c === null || i === null || i === 0 ? null : (c - i) / i;
+			o.push({
+				variant: s,
+				isBaseline: l,
+				isHoldout: this.def.holdout > 0 && s === "holdout",
+				exposure: r,
+				metric: c,
+				lift: d,
+				diff: u
+			});
+		}
+		return {
+			name: this.def.name,
+			table: this.def.on.table,
+			metric: this.def.metric.kind,
+			baseline: n,
+			totalExposure: a,
+			variants: o,
+			lastUpdatedAt: this.lastUpdatedAt,
+			...this.def.description === void 0 ? {} : { description: this.def.description }
+		};
+	}
+	metricValueFor(e, t, n) {
+		let r = t.get(e);
+		if (r !== void 0) return r;
+		if (this.metricIsCount) return n.get(e) ?? 0;
+		switch (this.def.metric.kind) {
+			case "sum": return 0;
+			default: return null;
+		}
+	}
+	get isSeeded() {
+		return this.seeded;
+	}
+}, p = (e) => {
+	let t = e.now ?? Date.now, n = e.log, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), a = (e) => {
+		for (let t of r) try {
+			t(e);
+		} catch (t) {
+			n.warn("experiment: update listener threw", { name: e.result.name }, t);
+		}
+	}, o = (t) => async () => await e.store.query({
+		table: t,
+		predicate: void 0,
+		order: [],
+		take: void 0,
+		skip: void 0,
+		projection: void 0
+	}), s = /* @__PURE__ */ new Map();
+	for (let { definition: r } of e.discovered) {
+		if (i.has(r.name)) throw Error(`experiment: duplicate name '${r.name}' — names must be unique across all experiments`);
+		let e = new f(r, {
+			queryBase: o(r.on.table),
+			now: t,
+			...n === void 0 ? {} : { log: n }
+		});
+		i.set(r.name, e);
+		let a = s.get(r.on.table) ?? [];
+		a.push(e), s.set(r.on.table, a);
+	}
+	(async () => {
+		for (let e of i.values()) try {
+			await e.seed();
+		} catch (e) {
+			n.warn("experiment: seed failed — will retry on reconcile", { err: String(e) });
+		}
+	})();
+	let c = e.store.onChange((e) => {
+		let t = s.get(e.table);
+		if (t === void 0 || t.length === 0) return;
+		let r = e.op !== "insert" && e.old == null || e.op !== "delete" && e.new == null;
+		(async () => {
+			for (let i of t) try {
+				if (r) await i.seed(), a({
+					result: i.result(),
+					cause: d(e)
+				});
+				else {
+					let t = i.applyChange(e);
+					t !== null && a(t);
+				}
+			} catch (e) {
+				n.warn("experiment: delta apply failed — reconcile will heal", { err: String(e) });
+			}
+		})();
+	}), l = setInterval(() => {
+		(async () => {
+			for (let e of i.values()) try {
+				await e.seed();
+			} catch {}
+		})();
+	}, e.reconcileIntervalMs ?? 3e5);
+	return l.unref?.(), {
+		registry: {
+			snapshot: () => {
+				let e = Array(i.size), t = 0;
+				return i.forEach((n) => {
+					e[t++] = n.result();
+				}), e;
+			},
+			get: (e) => i.get(e)?.result() ?? null,
+			subscribe: (e) => (r.add(e), () => r.delete(e))
+		},
+		detach: () => {
+			c(), clearInterval(l), r.clear();
+		},
+		registered: [...i.keys()]
+	};
+};
+//#endregion
+export { f as ExperimentEvaluator, p as attachExperiments };

package/dist/externalizedTasks.js

@@ -0,0 +1,25 @@
+//#region src/externalizedTasks.ts
+var e = 6e4, t = (e) => {
+	if (!Number.isFinite(e) || e < 6e4 || e % 6e4 != 0) return;
+	let t = e / 6e4;
+	if (t === 1) return "* * * * *";
+	if (t < 60) return 60 % t == 0 ? `*/${t} * * * *` : void 0;
+	if (t === 60) return "0 * * * *";
+	if (t % 60 != 0) return;
+	let n = t / 60;
+	return n < 24 ? 24 % n == 0 ? `0 */${n} * * *` : void 0 : n === 24 ? "0 0 * * *" : void 0;
+}, n = (e, n) => {
+	if (n < 6e4) return `"${e}" ticks every ${n} ms. No platform scheduler can express sub-minute cadence — and this is not a cron: its real trigger is an arrival, and the interval is only the ceiling for when reactivity is unavailable. It stays on its in-process timer.`;
+	if (t(n) === void 0) return `"${e}" ticks every ${n} ms, which no five-field cron expression fires at — cron matches instants rather than measuring intervals, so only cadences that tile the hour or the day evenly can be expressed. Choose an interval that divides 60 minutes or 24 hours. It stays on its in-process timer.`;
+}, r = Symbol.for("@voltro/externalizedCoordinatedTasks"), i = () => {
+	let e = globalThis, t = e[r];
+	if (t !== void 0) return t;
+	let n = /* @__PURE__ */ new Map();
+	return e[r] = n, n;
+}, a = (e) => {
+	i().set(e.name, e);
+}, o = (e) => {
+	i().delete(e);
+}, s = (e) => i().get(e), c = () => [...i().keys()].sort();
+//#endregion
+export { e as MIN_EXTERNALIZABLE_INTERVAL_MS, t as cronForInterval, n as externalizationRefusal, s as externalizedTask, c as externalizedTaskNames, a as registerExternalizedTask, o as unregisterExternalizedTask };