@voltro/plugin-flags 0.84.0 → 0.86.0

package/dist/index.js

@@ -1,584 +1,136 @@
 import { BASE_NAME as e, evaluateDescriptor as t, evaluateVariantsDescriptor as n, flagsRpcClientImports as r } from "./rpc.js";
-import { i, n as a, r as o, t as s } from "./define-D9Eet7wA.js";
-import { FlagDisabled as c } from "./errors.js";
-import { Effect as l } from "effect";
-import { definePlugin as u, pluginInstanceName as d } from "@voltro/protocol";
-import { boolean as f, derivedRowId as p, eq as m, id as h, integer as g, json as _, queryFor as v, registerRetention as y, retentionTtlMsFromEnv as b, table as x, text as S, timestamp as C } from "@voltro/database";
-//#region src/evaluate.ts
-var w = (e) => typeof e == "boolean" ? { enabled: e } : e, T = (e, t) => {
-	let n = 2166136261, r = `${e}:${t}`;
-	for (let e = 0; e < r.length; e++) n ^= r.charCodeAt(e), n = Math.imul(n, 16777619);
-	return n >>> 0;
-}, E = (e, t) => T(e, t) % 100, ee = (e, t) => T(`${e}:variant`, t) % 1e4, D = (e, t) => {
-	if (e.subjectIds && !(t.id != null && e.subjectIds.includes(t.id)) || e.tenantIds && !(t.tenantId != null && e.tenantIds.includes(t.tenantId)) || e.subjectTypes && !(t.type != null && e.subjectTypes.includes(t.type))) return !1;
-	if (e.metadata) {
-		let n = t.metadata ?? {};
-		for (let [t, r] of Object.entries(e.metadata)) if (String(n[t]) !== r) return !1;
-	}
-	return !0;
-}, O = (e) => typeof e == "number" ? e : Date.parse(e), k = (e, t) => (e.rolloutBy === "tenant" ? t.tenantId : t.id) ?? "anon", A = (e, t) => {
-	if (e.activateAt != null && t < O(e.activateAt) || e.deactivateAt != null && t >= O(e.deactivateAt)) return { active: !1 };
-	if (e.ramp) {
-		let { from: n, to: r, startAt: i, endAt: a } = e.ramp, o = O(i), s = O(a);
-		if (t <= o) return {
-			active: !0,
-			rollout: n
-		};
-		if (t >= s || s <= o) return {
-			active: !0,
-			rollout: r
-		};
-		let c = (t - o) / (s - o);
-		return {
-			active: !0,
-			rollout: n + (r - n) * c
-		};
-	}
-	return { active: !0 };
-}, j = (e, t, n, r = Date.now()) => {
-	let i = w(t);
-	if (i.enabled === !1) return !1;
-	let a;
-	if (i.schedule) {
-		let e = A(i.schedule, r);
-		if (!e.active) return !1;
-		a = e.rollout;
-	}
-	if (i.targeting && i.targeting.length > 0 && !i.targeting.some((e) => D(e, n))) return !1;
-	let o = a ?? i.rollout ?? 100;
-	if (o < 100 && o > 0) {
-		if (!(E(e, k(i, n)) < o)) return !1;
-	} else if (o <= 0) return !1;
-	return i.variants && i.variants.length > 0 && i.offVariant != null ? N(e, i, n).name !== i.offVariant : !0;
-}, M = (e) => {
-	let t = e.reduce((e, t) => e + (t.weight ?? 1), 0) || e.length, n = 0;
-	return e.map((r, i) => (n += r.weight ?? 1, i === e.length - 1 ? 1e4 : Math.round(n / t * 1e4)));
-}, N = (e, t, n) => {
-	let r = t.variants ?? [];
-	if (r.length === 0) throw Error(`flag "${e}" has no variants`);
-	let i = ee(e, k(t, n)), a = M(r);
-	for (let e = 0; e < r.length; e++) if (i < a[e]) return r[e];
-	return r[r.length - 1];
-}, P = (e, t, n, r = Date.now()) => {
-	let i = w(t), a = j(e, t, n, r);
-	if (!i.variants || i.variants.length === 0) return {
-		name: a ? "on" : "off",
-		value: a,
-		enabled: a
-	};
-	let o = N(e, i, n);
-	return {
-		name: o.name,
-		value: o.value,
-		enabled: a
-	};
-}, te = (e, t, n = Date.now()) => {
-	let r = {};
-	for (let [i, a] of Object.entries(e)) r[i] = j(i, a, t, n);
-	return r;
-}, ne = (e, t, n = Date.now()) => {
-	let r = {};
-	for (let [i, a] of Object.entries(e)) r[i] = P(i, a, t, n);
-	return r;
-}, F = "_voltro_feature_flag_audit", I = "_voltro_feature_flags", L = x(I, {
-	id: h({ prefix: "flag" }),
-	key: S().unique(),
-	enabled: f().default(!0),
-	rollout: g().nullable(),
-	rolloutBy: S().nullable(),
-	targeting: _().nullable(),
-	variants: _().nullable(),
-	offVariant: S().nullable(),
-	schedule: _().nullable(),
-	description: S().nullable(),
-	updatedAt: C().default("now").onUpdate("now")
-}), R = x(F, {
-	id: h({ prefix: "flagaud" }),
-	flag: S(),
-	enabled: f(),
-	previousEnabled: f().nullable(),
-	actorId: S().nullable(),
-	at: C().default("now")
-}).index("byFlagAuditFlag", ["flag"]).index("byFlagAuditAt", ["at"]), re = (e, t) => {
-	let n = { ...e };
-	for (let e of t) {
-		let t = {
-			enabled: e.enabled,
-			...e.rollout == null ? {} : { rollout: e.rollout },
-			...e.rolloutBy === "tenant" || e.rolloutBy === "subject" ? { rolloutBy: e.rolloutBy } : {},
-			...Array.isArray(e.targeting) ? { targeting: e.targeting } : {},
-			...Array.isArray(e.variants) ? { variants: e.variants } : {},
-			...e.offVariant == null ? {} : { offVariant: e.offVariant },
-			...e.schedule != null && typeof e.schedule == "object" ? { schedule: e.schedule } : {},
-			...e.description == null ? {} : { description: e.description }
-		};
-		n[e.key] = t;
-	}
-	return n;
-}, z = new class {
-	flags = {};
-	set(e) {
-		this.flags = e;
-	}
-	all() {
-		return this.flags;
-	}
-	get(e) {
-		return this.flags[e];
-	}
-}(), B = (e, t) => V(e, t) !== null, V = (e, t) => {
-	let n = z.get(e);
-	if (n === void 0) return null;
-	let r = w(n), i = r.enabled !== !1;
-	return z.set({
-		...z.all(),
-		[e]: {
-			...r,
-			enabled: t
-		}
-	}), i;
-}, H = (e) => Object.entries(e).map(([e, t]) => {
-	let n = w(t);
-	return {
-		key: e,
-		enabled: n.enabled !== !1,
-		rollout: n.rollout ?? 100,
-		variants: n.variants && n.variants.length > 0 ? n.variants.map((e) => e.name) : void 0,
-		scheduled: n.schedule != null,
-		description: n.description
-	};
-}), ie = (e, t) => {
-	let n = w(t);
-	return {
-		key: e,
-		enabled: n.enabled !== !1,
-		rollout: n.rollout ?? null,
-		rolloutBy: n.rolloutBy ?? null,
-		targeting: n.targeting ?? null,
-		variants: n.variants ?? null,
-		offVariant: n.offVariant ?? null,
-		schedule: n.schedule ?? null,
-		description: n.description ?? null
-	};
-}, ae = (e) => ({
-	loadOverrides: async () => (await e.query(v(L).descriptor)).map((e) => ({
-		key: String(e.key),
-		enabled: e.enabled === !0 || e.enabled === 1,
-		rollout: e.rollout == null ? null : Number(e.rollout),
-		rolloutBy: e.rolloutBy ?? null,
-		targeting: e.targeting ?? null,
-		variants: e.variants ?? null,
-		offVariant: e.offVariant ?? null,
-		schedule: e.schedule ?? null,
-		description: e.description ?? null
-	})),
-	upsertOverride: async (t) => {
-		let n = U(t);
-		await e.upsert(I, n, { conflictColumns: ["key"] });
-	}
-}), U = (e) => ({
-	id: p("flag", e.key),
-	key: e.key,
-	enabled: e.enabled,
-	rollout: e.rollout,
-	rolloutBy: e.rolloutBy,
-	targeting: e.targeting,
-	variants: e.variants,
-	offVariant: e.offVariant,
-	schedule: e.schedule,
-	description: e.description,
-	updatedAt: /* @__PURE__ */ new Date()
-}), oe = (e) => ({
-	flag: String(e.flag),
-	enabled: e.enabled === !0 || e.enabled === 1,
-	previousEnabled: e.previousEnabled == null ? null : e.previousEnabled === !0 || e.previousEnabled === 1,
-	actorId: e.actorId ?? null,
-	at: e.at instanceof Date ? e.at : new Date(String(e.at))
-}), se = (e) => ({
-	record: async (t) => {
-		await e.insert(F, {
-			id: `flagaud_${t.at.getTime()}_${Math.random().toString(36).slice(2, 10)}`,
-			flag: t.flag,
-			enabled: t.enabled,
-			previousEnabled: t.previousEnabled,
-			actorId: t.actorId,
-			at: t.at
-		});
-	},
-	list: async (t) => {
-		let n = v(R).orderBy("at", "desc");
-		return t?.flag != null && (n = n.where(m("flag", t.flag))), t?.limit != null && (n = n.limit(t.limit)), (await e.query(n.descriptor)).map(oe);
-	}
-}), ce = async (e, t, n, r, i) => {
-	await e.transactional(async (e) => {
-		await e.insertIgnore(I, {
-			...U(ie(t, n)),
-			id: p("flag", crypto.randomUUID())
-		}, { conflictColumns: ["key"] });
-		let a = (await e.query(v(L).where(m("key", t)).forUpdate().descriptor))[0];
-		if (!a) throw Error("flag override disappeared during toggle");
-		await e.update(I, String(a.id), {
-			enabled: r,
-			updatedAt: /* @__PURE__ */ new Date()
-		}), await se(e).record({
-			flag: t,
-			enabled: r,
-			previousEnabled: a.enabled === !0 || a.enabled === 1,
-			actorId: i,
-			at: /* @__PURE__ */ new Date()
-		});
-	});
-}, W = (e, t) => {
-	let n = new Map(t.map((e) => [e.name, e])), r = [];
-	for (let t of e) {
-		let e = t.experiment;
-		if (e === void 0) continue;
-		let i = n.get(e);
-		if (i === void 0) {
-			r.push({
-				flag: t.key,
-				experiment: e,
-				problem: `no experiment named ${JSON.stringify(e)} was passed to flagsPlugin({ experiments }). Pass the defineExperiment() definitions the app declares, or drop the \`experiment\` link.`
-			});
-			continue;
-		}
-		(i.variantFrom === void 0 || i.variantFrom === null) && r.push({
-			flag: t.key,
-			experiment: e,
-			problem: `the experiment assigns its own arms (\`subject\` mode), so it would measure a split this flag never served — the two bucketings are independent hashes. Persist the served arm (\`flagVariant(ctx, ${JSON.stringify(t.key)})\`) on the watched table and declare the experiment with \`variantFrom: <that column>\`.`
-		}), typeof i.holdout == "number" && i.holdout > 0 && r.push({
-			flag: t.key,
-			experiment: e,
-			problem: `holdout ${i.holdout} is carved at ASSIGNMENT, and this flag does the assigning — the experiment can never place a row there. Declare the holdout as a flag variant instead.`
-		});
-		let a = new Set(t.variants.map((e) => e.name)), o = new Set(i.variants.map((e) => e.name));
-		if (a.size === 0) r.push({
-			flag: t.key,
-			experiment: e,
-			problem: "the flag declares no variants, so it serves one value to everyone and there is nothing to compare."
-		});
-		else {
-			let n = [...a].filter((e) => !o.has(e)), i = [...o].filter((e) => !a.has(e));
-			(n.length > 0 || i.length > 0) && r.push({
-				flag: t.key,
-				experiment: e,
-				problem: `the arms disagree — ${n.length > 0 ? `served by the flag but not declared by the experiment: ${n.join(", ")}` : ""}${n.length > 0 && i.length > 0 ? "; " : ""}${i.length > 0 ? `declared by the experiment but never served: ${i.join(", ")}` : ""}. A row assigned to an arm the experiment does not declare is EXCLUDED, so the mismatch shows up as an empty arm rather than an error.`
-			});
-		}
-	}
-	return r;
-}, le = (e, t) => {
-	let n = W(e, t);
-	if (n.length === 0) return;
-	let r = n.map((e) => `  · flag "${e.flag}" → experiment "${e.experiment}": ${e.problem}`);
-	throw Error(`@voltro/plugin-flags: ${n.length} flag→experiment link problem(s):\n${r.join("\n")}`);
-}, ue = 864e5, G = (e) => typeof e == "number" ? e : Date.parse(e), K = (e, t) => {
-	let n = w(e);
-	if (n.enabled === !1) return {
-		shape: "constantOff",
-		reason: "enabled: false — resolves false for every caller"
-	};
-	if (n.schedule) {
-		let { activateAt: e, deactivateAt: r } = n.schedule;
-		if (r != null && t >= G(r)) return {
-			shape: "expired",
-			reason: `schedule.deactivateAt (${String(r)}) has passed — the flag can never be on again`
-		};
-		if (e != null && t < G(e)) return {
-			shape: "notYetActive",
-			reason: `schedule.activateAt (${String(e)}) is in the future — pending, not dead`
-		};
-	}
-	let r = n.rollout ?? 100;
-	if (r <= 0) return {
-		shape: "constantOff",
-		reason: `rollout: ${r} — nobody is in the rollout`
-	};
-	let i = (n.targeting?.length ?? 0) > 0, a = (n.variants?.length ?? 0) > 1, o = n.schedule !== void 0 && (n.schedule.ramp !== void 0 || n.schedule.deactivateAt != null && t < G(n.schedule.deactivateAt));
-	return r >= 100 && !i && !a && !o ? {
-		shape: "constantOn",
-		reason: "rollout 100 with no targeting, no variants and no live schedule — resolves true for every caller"
-	} : {
-		shape: "conditional",
-		reason: `still selects between callers (${[
-			r < 100 ? `rollout ${r}%` : void 0,
-			i ? `${n.targeting?.length} targeting rule(s)` : void 0,
-			a ? `${n.variants?.length} variants` : void 0,
-			o ? "a live schedule" : void 0
-		].filter((e) => e !== void 0).join(", ")})`
-	};
-}, de = [
-	"Reachability is not decided. \"Not evaluated since <date>\" is a measurement; \"this code path is dead\" is not decidable in general. A seasonal flag, a flag behind a route nobody visited this month, and a flag whose last call site was deleted are indistinguishable from here.",
-	"Only SERVER-side reads are counted as use: isFlagEnabled / requireFlag / flagValue and a gatedBy interception. A flag consulted only in the browser via useFlag() / useFlagValue() reads from the bulk set the server already sent, so it never reaches this report as a named read.",
-	"A \"bulk\" observation means the flag was INCLUDED in a flags.evaluate / flags.variants response. It does not mean any client read that key — one useFlags() poll evaluates the whole registry.",
-	"The window is bounded by retention (see coverage.retentionDays). Nothing older is evidence: a flag last read BEFORE the window has no observation at all and reads \"neverObserved\", which is exactly what a flag declared this morning reads.",
-	"\"neverObserved\" is not a removal candidate. A flag declared yesterday and a flag abandoned last year produce the identical row; only a flag that WAS observed and then stopped (\"stale\") is proven unused."
-], fe = (e) => {
-	let t = e.now ?? Date.now(), n = e.staleAfterDays, r = t - n * ue, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o;
-	for (let t of e.usage) {
-		let e = t.lastAt.getTime();
-		if (!Number.isFinite(e)) continue;
-		(o === void 0 || e < o) && (o = e);
-		let n = t.source === "bulk" ? a : i, r = n.get(t.flag);
-		(r === void 0 || e > r) && n.set(t.flag, e);
-	}
-	let s = o === void 0 ? 0 : Math.floor((t - o) / ue);
-	return {
-		coverage: {
-			tracking: e.tracking,
-			observedSince: o === void 0 ? null : new Date(o).toISOString().slice(0, 10),
-			observedDays: s,
-			retentionDays: e.retentionDays,
-			staleAfterDays: n
-		},
-		findings: Object.entries(e.flags).map(([o, c]) => {
-			let { shape: l, reason: u } = K(c, t), d = i.get(o), f = a.get(o), p = [u], m;
-			e.tracking ? d !== void 0 && d >= r ? (m = "evaluated", p.push(`last server-side read ${new Date(d).toISOString()}`)) : d === void 0 ? (m = "neverObserved", p.push(s > 0 ? `no server-side read in the ${s}-day observation window` : "no server-side read observed yet (the observation window is empty)"), f !== void 0 && p.push("the flag WAS delivered to a client in a bulk flags.evaluate response — which does not prove it was read")) : (m = "stale", p.push(`last server-side read ${new Date(d).toISOString()}, more than ${n} day(s) ago, over an observation window of ${s} day(s)`)) : (m = "untracked", p.push("evaluation tracking is off — no usage evidence exists for this deployment"));
-			let h = l === "constantOn" || l === "constantOff" || l === "expired";
-			return h && p.push("the definition alone makes this flag a constant — it selects nothing"), {
-				key: o,
-				shape: l,
-				shapeReason: u,
-				usage: m,
-				lastTargetedAt: d === void 0 ? null : new Date(d).toISOString(),
-				lastBulkAt: f === void 0 ? null : new Date(f).toISOString(),
-				liveTargetedEvaluations: e.liveCounts?.get(o) ?? 0,
-				removalCandidate: h || m === "stale",
-				why: p
-			};
-		}),
-		limits: de
-	};
-}, q = "_voltro_feature_flag_usage", J = x(q, {
-	id: h({ prefix: "flagusg" }),
-	flag: S(),
-	day: S(),
-	source: S(),
-	lastAt: C()
-}).unique([
-	"flag",
-	"day",
-	"source"
-]).index("byFlagUsageLastAt", ["lastAt"]).index("byFlagUsageFlag", ["flag"]), pe = (e) => e.toISOString().slice(0, 10), me = (e) => {
-	let t = 2166136261;
-	for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
-	return (t >>> 0).toString(16).padStart(8, "0");
-}, he = (e, t, n) => `flagusg_${t.replace(/-/g, "")}_${n === "targeted" ? "t" : "b"}_${me(e)}`, Y = new class {
-	on = !1;
-	pending = /* @__PURE__ */ new Map();
-	liveCounts = /* @__PURE__ */ new Map();
-	enable() {
-		this.on = !0;
-	}
-	disable() {
-		this.on = !1, this.pending.clear();
-	}
-	get enabled() {
-		return this.on;
-	}
-	record(e, t, n = Date.now()) {
-		if (!this.on) return;
-		let r = `${t}\u0000${e}`, i = this.pending.get(r);
-		i ? i.lastAt = n : this.pending.set(r, {
-			flag: e,
-			source: t,
-			lastAt: n
-		}), t === "targeted" && this.liveCounts.set(e, (this.liveCounts.get(e) ?? 0) + 1);
-	}
-	drain() {
-		let e = [...this.pending.values()];
-		return this.pending.clear(), e;
-	}
-	restore(e) {
-		if (this.on) for (let t of e) {
-			let e = `${t.source}\u0000${t.flag}`, n = this.pending.get(e);
-			(!n || n.lastAt < t.lastAt) && this.pending.set(e, { ...t });
-		}
-	}
-	liveTargetedCounts() {
-		return this.liveCounts;
-	}
-	reset() {
-		this.on = !1, this.pending.clear(), this.liveCounts.clear();
-	}
-}(), X = (e, t, n) => Y.record(e, t, n), ge = (e) => e === "bulk" ? "bulk" : "targeted", _e = (e) => ({
-	upsertMany: async (t) => {
-		for (let n of t) {
-			let t = pe(n.lastAt);
-			await e.upsert(q, {
-				id: he(n.flag, t, n.source),
-				flag: n.flag,
-				day: t,
-				source: n.source,
-				lastAt: n.lastAt
-			}, { conflictColumns: [
-				"flag",
-				"day",
-				"source"
-			] });
-		}
-	},
-	load: async () => (await e.query(v(J).descriptor)).map((e) => ({
-		flag: String(e.flag),
-		day: String(e.day),
-		source: ge(e.source),
-		lastAt: e.lastAt instanceof Date ? e.lastAt : new Date(String(e.lastAt))
-	}))
-}), ve = 3e5, ye = (e) => {
-	let t = e.intervalMs ?? 3e5, n = !1, r = async () => {
-		let t = Y.drain();
-		if (t.length !== 0) try {
-			await e.store.upsertMany(t.map((e) => ({
-				flag: e.flag,
-				source: e.source,
-				lastAt: new Date(e.lastAt)
-			})));
-		} catch (n) {
-			Y.restore(t), e.log?.warn?.("flag usage flush failed — observations retained for the next pass", {
-				pending: t.length,
-				cause: n.message
-			});
-		}
-	}, i = setInterval(() => {
-		r();
-	}, t);
-	return typeof i.unref == "function" && i.unref(), {
-		flushNow: r,
-		stop: async () => {
-			n || (n = !0, clearInterval(i), await r());
-		}
-	};
-}, be = (e = process.env, t = 90) => {
-	let n = b(e.VOLTRO_FLAG_USAGE_TTL_HOURS, 24 * t);
-	return y({
-		table: q,
-		timeColumn: "lastAt",
-		source: "plugin",
-		ttlMs: n,
-		envVar: "VOLTRO_FLAG_USAGE_TTL_HOURS"
-	}), n;
-}, Z = (e) => "request" in e && e.request?.subject || "subject" in e && e.subject || {}, Q = (e, t) => {
-	let n = z.get(t);
-	return X(t, "targeted"), n !== void 0 && j(t, n, Z(e));
-}, xe = (e, t) => Q(e, t) ? l.void : l.fail(new c({ flag: t })), Se = (e, t) => {
-	let n = z.get(t.key);
-	return X(t.key, "targeted"), n === void 0 ? t.defaultValue : i(t, P(t.key, n, Z(e)));
-}, Ce = (e, t) => {
-	let n = z.get(t.key);
-	return X(t.key, "targeted"), n === void 0 ? null : P(t.key, n, Z(e)).name;
-}, we = (e, t) => e === t || e.startsWith("/") && e.endsWith("/") && new RegExp(e.slice(1, -1)).test(t), $ = e, Te = (e = {}) => {
-	let i = e.gatedBy ?? {}, o = d({
-		base: $,
+import { evaluateAll as i, evaluateAllVariants as a, evaluateFlag as o, evaluateSchedule as s, evaluateVariant as c, resolveVariant as l, toDefinition as u } from "./evaluate.js";
+import { dataStoreFlagAuditStore as ee, dataStoreFlagStore as d, describeFlags as f, featureFlagsTable as p, flagAuditTable as m, flipFlagEnabled as h, mergeOverrides as g, persistFlagToggle as te, registry as _, setFlagEnabled as v } from "./store.js";
+import { defineFlag as y, gateOverride as b, isTypedFlag as x, typedValueOf as S } from "./define.js";
+import { assertFlagExperimentLinks as C, checkFlagExperimentLinks as w } from "./experimentLink.js";
+import { FLAG_LIFECYCLE_LIMITS as T, classifyShape as E, flagLifecycleReport as D } from "./lifecycle.js";
+import { DEFAULT_FLAG_USAGE_FLUSH_MS as O, FLAG_USAGE_TABLE as k, dataStoreFlagUsageStore as A, flagUsageBuffer as j, flagUsageRowId as M, flagUsageTable as N, recordFlagEvaluation as P, registerFlagUsageRetention as F, startFlagUsageFlush as I, utcDay as L } from "./usage.js";
+import { FlagDisabled as R } from "./errors.js";
+import { Effect as z, Result as B } from "effect";
+import { definePlugin as ne, pluginInstanceName as re } from "@voltro/protocol";
+//#region src/index.ts
+var V = (e) => "request" in e && e.request?.subject || "subject" in e && e.subject || {}, H = (e, t) => {
+	let n = _.get(t);
+	return P(t, "targeted"), n !== void 0 && o(t, n, V(e));
+}, U = (e, t) => H(e, t) ? z.void : z.fail(new R({ flag: t })), W = (e, t) => {
+	let n = _.get(t.key);
+	return P(t.key, "targeted"), n === void 0 ? t.defaultValue : S(t, c(t.key, n, V(e)));
+}, G = (e, t) => {
+	let n = _.get(t.key);
+	return P(t.key, "targeted"), n === void 0 ? null : c(t.key, n, V(e)).name;
+}, ie = (e, t) => e === t || e.startsWith("/") && e.endsWith("/") && new RegExp(e.slice(1, -1)).test(t), K = e, q = (e = {}) => {
+	let o = e.gatedBy ?? {}, s = re({
+		base: K,
 		alias: e.alias,
 		instance: e.name
-	}), s = e.typedFlags ?? [], f = /* @__PURE__ */ new Map();
-	for (let t of s) {
-		if (f.has(t.key)) throw Error(`${$}: two typedFlags declare the key ${JSON.stringify(t.key)}`);
-		if (e.flags?.[t.key] !== void 0) throw Error(`${$}: ${JSON.stringify(t.key)} is declared BOTH in \`flags\` and in \`typedFlags\`. One key, one declaration — the typed one would otherwise be silently overwritten by the untyped baseline.`);
-		f.set(t.key, t);
-	}
-	s.some((e) => e.experiment !== void 0) && le(s, e.experiments ?? []);
-	let p = { ...e.flags ?? {} };
-	for (let e of s) p[e.key] = e.definition;
-	let m = e.store === "postgres", h, g, _, v, y, b, x, S = [], C = e.usage ?? {}, w = C.track ?? m;
-	if (w && !m) throw Error(`${$}: usage.track requires store: 'postgres' — there is nowhere to record an evaluation on the memory tier, and a dead-flag report that silently observed nothing is exactly the defect it exists to find.`);
-	let T = C.staleAfterDays ?? 30, E = C.retentionDays ?? 90;
-	if (T > E) throw Error(`${$}: usage.staleAfterDays (${T}) exceeds usage.retentionDays (${E}), so the observation window can never be long enough to prove a flag stale and every verdict would be withheld.`);
-	let ee = (e) => {
-		let t = re(p, e), n = [];
-		for (let [e, r] of f) {
+	}), c = e.typedFlags ?? [], l = /* @__PURE__ */ new Map();
+	for (let t of c) {
+		if (l.has(t.key)) throw Error(`${K}: two typedFlags declare the key ${JSON.stringify(t.key)}`);
+		if (e.flags?.[t.key] !== void 0) throw Error(`${K}: ${JSON.stringify(t.key)} is declared BOTH in \`flags\` and in \`typedFlags\`. One key, one declaration — the typed one would otherwise be silently overwritten by the untyped baseline.`);
+		l.set(t.key, t);
+	}
+	c.some((e) => e.experiment !== void 0) && C(c, e.experiments ?? []);
+	let u = { ...e.flags ?? {} };
+	for (let e of c) u[e.key] = e.definition;
+	let v = e.store === "postgres", y, x, S, w, T, E, O, k = [], M = e.usage ?? {}, L = M.track ?? v;
+	if (L && !v) throw Error(`${K}: usage.track requires store: 'postgres' — there is nowhere to record an evaluation on the memory tier, and a dead-flag report that silently observed nothing is exactly the defect it exists to find.`);
+	let V = M.staleAfterDays ?? 30, U = M.retentionDays ?? 90;
+	if (V > U) throw Error(`${K}: usage.staleAfterDays (${V}) exceeds usage.retentionDays (${U}), so the observation window can never be long enough to prove a flag stale and every verdict would be withheld.`);
+	let W = (e) => {
+		let t = g(u, e), n = [];
+		for (let [e, r] of l) {
 			let i = t[e];
 			if (i === void 0) continue;
-			let o = a(r, typeof i == "boolean" ? { enabled: i } : i);
-			o.ok || (n.push(o.refusal), t[e] = r.definition);
+			let a = b(r, typeof i == "boolean" ? { enabled: i } : i);
+			a.ok || (n.push(a.refusal), t[e] = r.definition);
 		}
-		S = n, z.set(t);
-	}, D = 0, O = async () => {
-		if (!g) return;
-		let e = ++D, t = await g.loadOverrides();
-		e === D && ee(t);
-	}, k = async () => {
-		if (b && g) {
-			if (await O(), w && v && !y) {
-				x = be(process.env, E), Y.enable();
-				let e = b.logger;
-				y = ye({
-					store: v,
-					intervalMs: C.flushIntervalMs ?? 3e5,
+		k = n, _.set(t);
+	}, G = 0, q = async () => {
+		if (!x) return;
+		let e = ++G, t = await x.loadOverrides();
+		e === G && W(t);
+	}, J = async () => {
+		if (E && x) {
+			if (await q(), L && w && !T) {
+				O = F(process.env, U), j.enable();
+				let e = E.logger;
+				T = I({
+					store: w,
+					intervalMs: M.flushIntervalMs ?? 3e5,
 					log: { warn: (t, n) => e.warn(t, n) }
 				});
 			}
-			for (let e of S) b.logger.warn("feature flag override REFUSED — code-declared definition stands", {
+			for (let e of k) E.logger.warn("feature flag override REFUSED — code-declared definition stands", {
 				flag: e.key,
 				reason: e.reason
 			});
 		}
-	}, A = (e) => {
-		if (i[e] !== void 0) return i[e];
-		for (let [t, n] of Object.entries(i)) if (t !== e && we(t, e)) return n;
-	}, j = (e, t) => {
-		let n = A(t.tag);
-		return n === void 0 || Q({ subject: t.subject }, n) ? e : l.fail(new c({ flag: n }));
-	}, M = Object.keys(i).length > 0, N = (e) => {
-		for (let t of e) X(t, "bulk");
-	}, P = {
+	}, ae = (e) => {
+		if (o[e] !== void 0) return o[e];
+		for (let [t, n] of Object.entries(o)) if (t !== e && ie(t, e)) return n;
+	}, Y = (e, t) => {
+		let n = ae(t.tag);
+		return n === void 0 || H({ subject: t.subject }, n) ? e : z.fail(new R({ flag: n }));
+	}, X = Object.keys(o).length > 0, Z = (e) => {
+		for (let t of e) P(t, "bulk");
+	}, oe = {
 		...t,
 		description: "Resolve every feature flag for the calling subject.",
-		execute: (e, t) => l.sync(() => {
-			let e = z.all();
-			return N(Object.keys(e)), te(e, t.request.subject ?? {});
+		execute: (e, t) => z.sync(() => {
+			let e = _.all();
+			return Z(Object.keys(e)), i(e, t.request.subject ?? {});
 		})
-	}, F = {
+	}, se = {
 		...n,
 		description: "Resolve every feature flag to its served variant for the calling subject.",
-		execute: (e, t) => l.sync(() => {
-			let e = z.all();
-			return N(Object.keys(e)), ne(e, t.request.subject ?? {});
+		execute: (e, t) => z.sync(() => {
+			let e = _.all();
+			return Z(Object.keys(e)), a(e, t.request.subject ?? {});
 		})
-	}, I = (e) => ({
+	}, Q = (e) => ({
 		kind: "json",
 		data: e
-	}), B = (e, t) => ({
+	}), $ = (e, t) => ({
 		kind: "json",
 		status: e,
 		data: { error: t }
-	}), ie = async () => {
+	}), ce = async () => {
 		let e = [];
-		if (w && v) try {
-			e = await v.load();
+		if (L && w) try {
+			e = await w.load();
 		} catch {
 			e = [];
 		}
-		return fe({
-			flags: z.all(),
+		return D({
+			flags: _.all(),
 			usage: e,
-			tracking: w,
-			liveCounts: Y.liveTargetedCounts(),
-			staleAfterDays: T,
-			retentionDays: E
+			tracking: L,
+			liveCounts: j.liveTargetedCounts(),
+			staleAfterDays: V,
+			retentionDays: U
 		});
-	}, U = () => {
+	}, le = () => {
 		let e = {};
-		for (let [t, n] of f) e[t] = {
+		for (let [t, n] of l) e[t] = {
 			valueType: n.valueType,
 			variants: n.variants.map((e) => e.name),
 			experiment: n.experiment ?? null
 		};
 		return e;
-	}, oe = [
+	}, ue = [
 		{
 			method: "GET",
 			path: "/list",
 			scope: "process",
 			description: "Every resolved flag (key, enabled, rollout, description) plus the dead-flag lifecycle report: per-flag shape + usage verdict, the observation coverage window, and the limits of what the report can prove.",
-			handler: () => l.promise(async () => {
-				let e = await ie();
-				return I({
-					flags: H(z.all()),
-					writeScope: m ? "shared-store" : "process",
+			handler: () => z.promise(async () => {
+				let e = await ce();
+				return Q({
+					flags: f(_.all()),
+					writeScope: v ? "shared-store" : "process",
 					lifecycle: e,
-					typed: U(),
-					overrideRefusals: S
+					typed: le(),
+					overrideRefusals: k
 				});
 			})
 		},
@@ -586,44 +138,45 @@ var w = (e) => typeof e == "boolean" ? { enabled: e } : e, T = (e, t) => {
 			method: "POST",
 			path: "/toggle",
 			description: "Flip a flag's kill-switch on/off (live registry; durable on the postgres tier). Logs an audit row.",
-			handler: (e) => l.gen(function* () {
+			handler: (e) => z.gen(function* () {
 				let t;
 				try {
 					t = JSON.parse(e.body || "{}");
 				} catch {
-					return B(400, "invalid JSON body");
+					return $(400, "invalid JSON body");
 				}
-				if (!t || typeof t.key != "string" || !t.key || typeof t.enabled != "boolean") return B(400, "key (string) + enabled (boolean) required");
-				let n = t.key, r = t.enabled, i = z.get(n);
-				if (i === void 0) return B(404, `unknown flag "${n}"`);
-				if (m) {
-					let e = h;
-					if (!e) return B(503, "flag store is not ready");
-					if ((yield* l.tryPromise(async () => {
-						await ce(e, n, i, r, typeof t.actor == "string" ? t.actor : null), await O();
-					}).pipe(l.either))._tag === "Left") return yield* l.tryPromise(O).pipe(l.ignore), B(503, "flag update could not be confirmed; reload the flag state before retrying");
-				} else V(n, r);
-				return I({
+				if (!t || typeof t.key != "string" || !t.key || typeof t.enabled != "boolean") return $(400, "key (string) + enabled (boolean) required");
+				let n = t.key, r = t.enabled, i = _.get(n);
+				if (i === void 0) return $(404, `unknown flag "${n}"`);
+				if (v) {
+					let e = y;
+					if (!e) return $(503, "flag store is not ready");
+					let a = yield* z.tryPromise(async () => {
+						await te(e, n, i, r, typeof t.actor == "string" ? t.actor : null), await q();
+					}).pipe(z.result);
+					if (B.isFailure(a)) return yield* z.tryPromise(q).pipe(z.ignore), $(503, "flag update could not be confirmed; reload the flag state before retrying");
+				} else h(n, r);
+				return Q({
 					ok: !0,
-					flags: H(z.all())
+					flags: f(_.all())
 				});
 			})
 		},
 		{
 			method: "GET",
 			path: "/audit",
-			scope: m ? "shared-store" : "declaration",
+			scope: v ? "shared-store" : "declaration",
 			description: "The kill-switch flip audit trail, newest-first. `?flag=<key>` filters; `?limit=<n>` caps (postgres tier only).",
-			handler: (e) => l.gen(function* () {
-				if (!_) return I({
+			handler: (e) => z.gen(function* () {
+				if (!S) return Q({
 					audit: [],
 					note: "audit trail requires store: \"postgres\""
 				});
-				let t = new URL(e.url, "http://local"), n = t.searchParams.get("flag"), r = t.searchParams.get("limit"), i = r != null && Number.isFinite(Number(r)) ? Number(r) : 100, a = yield* l.promise(() => _.list({
+				let t = new URL(e.url, "http://local"), n = t.searchParams.get("flag"), r = t.searchParams.get("limit"), i = r != null && Number.isFinite(Number(r)) ? Number(r) : 100, a = yield* z.promise(() => S.list({
 					...n == null ? {} : { flag: n },
 					limit: i
 				}));
-				return I({ audit: a.map((e) => ({
+				return Q({ audit: a.map((e) => ({
 					flag: e.flag,
 					enabled: e.enabled,
 					previousEnabled: e.previousEnabled,
@@ -632,60 +185,60 @@ var w = (e) => typeof e == "boolean" ? { enabled: e } : e, T = (e, t) => {
 				})) });
 			})
 		}
-	], W = [
-		...M ? [
+	], de = [
+		...X ? [
 			"rpc:intercept:mutation",
 			"rpc:intercept:query",
 			"rpc:intercept:action",
 			"rpc:intercept:workflow"
 		] : [],
-		...m ? ["store:write", "store:changes:read"] : [],
+		...v ? ["store:write", "store:changes:read"] : [],
 		"inspect:read",
 		"inspect:write"
 	];
-	return u({
-		name: o,
-		baseName: $,
+	return ne({
+		name: s,
+		baseName: K,
 		description: "Feature flags — targeting, % rollout, kill-switch, declarative gating + client evaluation.",
-		permissions: W,
-		routes: [P, F],
+		permissions: de,
+		routes: [oe, se],
 		rpcClientDescriptors: r,
-		inspectEndpoints: oe,
+		inspectEndpoints: ue,
 		errorSchemas: [{
-			schema: c,
+			schema: R,
 			import: {
 				module: "@voltro/plugin-flags/errors",
 				name: "FlagDisabled"
 			}
 		}],
-		...M ? {
-			interceptMutation: j,
-			interceptQuery: j,
-			interceptAction: j,
-			interceptWorkflow: j
+		...X ? {
+			interceptMutation: Y,
+			interceptQuery: Y,
+			interceptAction: Y,
+			interceptWorkflow: Y
 		} : {},
-		...m ? { extendSchema: { tables: w ? [
-			L,
-			R,
-			J
-		] : [L, R] } } : {},
-		...m ? { bindDataStore: async (e) => {
-			h = e, g = ae(h), _ = se(e), w && (v = _e(e)), await k();
+		...v ? { extendSchema: { tables: L ? [
+			p,
+			m,
+			N
+		] : [p, m] } } : {},
+		...v ? { bindDataStore: async (e) => {
+			y = e, x = d(y), S = ee(e), L && (w = A(e)), await J();
 		} } : {},
-		...m ? { onChangeEvent: (e) => e.table === "_voltro_feature_flags" ? l.tryPromise(() => O()) : l.void } : {},
-		onActivate: (t) => l.gen(function* () {
-			z.set(p), b = t, g && (yield* l.promise(k)), t.logger.info("feature flags active", {
-				count: Object.keys(p).length,
-				typed: f.size,
-				gated: Object.keys(i).length,
+		...v ? { onChangeEvent: (e) => e.table === "_voltro_feature_flags" ? z.tryPromise(() => q()) : z.void } : {},
+		onActivate: (t) => z.gen(function* () {
+			_.set(u), E = t, x && (yield* z.promise(J)), t.logger.info("feature flags active", {
+				count: Object.keys(u).length,
+				typed: l.size,
+				gated: Object.keys(o).length,
 				store: e.store ?? "memory",
-				usage: w ? y ? `tracking (stale after ${T}d, observations kept ${Math.round((x ?? 0) / 864e5)}d)` : "waiting for store binding" : "off — no dead-flag evidence is collected"
+				usage: L ? T ? `tracking (stale after ${V}d, observations kept ${Math.round((O ?? 0) / 864e5)}d)` : "waiting for store binding" : "off — no dead-flag evidence is collected"
 			});
 		}),
-		onDeactivate: () => l.promise(async () => {
-			b = void 0, await y?.stop(), y = void 0, Y.disable(), z.set({});
+		onDeactivate: () => z.promise(async () => {
+			E = void 0, await T?.stop(), T = void 0, j.disable(), _.set({});
 		})
 	});
 };
 //#endregion
-export { ve as DEFAULT_FLAG_USAGE_FLUSH_MS, de as FLAG_LIFECYCLE_LIMITS, q as FLAG_USAGE_TABLE, c as FlagDisabled, le as assertFlagExperimentLinks, W as checkFlagExperimentLinks, K as classifyShape, _e as dataStoreFlagUsageStore, s as defineFlag, H as describeFlags, te as evaluateAll, ne as evaluateAllVariants, j as evaluateFlag, A as evaluateSchedule, P as evaluateVariant, L as featureFlagsTable, R as flagAuditTable, fe as flagLifecycleReport, z as flagRegistry, Y as flagUsageBuffer, he as flagUsageRowId, J as flagUsageTable, Se as flagValue, Ce as flagVariant, Te as flagsPlugin, V as flipFlagEnabled, a as gateOverride, Q as isFlagEnabled, o as isTypedFlag, re as mergeOverrides, X as recordFlagEvaluation, be as registerFlagUsageRetention, xe as requireFlag, N as resolveVariant, B as setFlagEnabled, ye as startFlagUsageFlush, w as toDefinition, i as typedValueOf, pe as utcDay };
+export { O as DEFAULT_FLAG_USAGE_FLUSH_MS, T as FLAG_LIFECYCLE_LIMITS, k as FLAG_USAGE_TABLE, R as FlagDisabled, C as assertFlagExperimentLinks, w as checkFlagExperimentLinks, E as classifyShape, A as dataStoreFlagUsageStore, y as defineFlag, f as describeFlags, i as evaluateAll, a as evaluateAllVariants, o as evaluateFlag, s as evaluateSchedule, c as evaluateVariant, p as featureFlagsTable, m as flagAuditTable, D as flagLifecycleReport, _ as flagRegistry, j as flagUsageBuffer, M as flagUsageRowId, N as flagUsageTable, W as flagValue, G as flagVariant, q as flagsPlugin, h as flipFlagEnabled, b as gateOverride, H as isFlagEnabled, x as isTypedFlag, g as mergeOverrides, P as recordFlagEvaluation, F as registerFlagUsageRetention, U as requireFlag, l as resolveVariant, v as setFlagEnabled, I as startFlagUsageFlush, u as toDefinition, S as typedValueOf, L as utcDay };