@voltro/plugin-flags 0.85.0 → 0.86.0

package/dist/index.js

@@ -1,586 +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-BHpLJh1F.js";
-import { FlagDisabled as c } from "./errors.js";
-import { Effect as l, Result as u } from "effect";
-import { definePlugin as d, pluginInstanceName as f } from "@voltro/protocol";
-import { boolean as p, derivedRowId as m, eq as h, id as g, integer as _, json as v, queryFor as y, registerRetention as b, retentionTtlMsFromEnv as x, table as S, text as C, timestamp as w } from "@voltro/database";
-//#region src/evaluate.ts
-var T = (e) => typeof e == "boolean" ? { enabled: e } : e, E = (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;
-}, D = (e, t) => E(e, t) % 100, O = (e, t) => E(`${e}:variant`, t) % 1e4, k = (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;
-}, A = (e) => typeof e == "number" ? e : Date.parse(e), j = (e, t) => (e.rolloutBy === "tenant" ? t.tenantId : t.id) ?? "anon", M = (e, t) => {
-	if (e.activateAt != null && t < A(e.activateAt) || e.deactivateAt != null && t >= A(e.deactivateAt)) return { active: !1 };
-	if (e.ramp) {
-		let { from: n, to: r, startAt: i, endAt: a } = e.ramp, o = A(i), s = A(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 };
-}, N = (e, t, n, r = Date.now()) => {
-	let i = T(t);
-	return P(e, i, n, r) ? !i.variants?.length || i.offVariant == null || I(e, i, n).name !== i.offVariant : !1;
-}, P = (e, t, n, r) => {
-	if (t.enabled === !1) return !1;
-	let i;
-	if (t.schedule) {
-		let e = M(t.schedule, r);
-		if (!e.active) return !1;
-		i = e.rollout;
-	}
-	if (t.targeting && t.targeting.length > 0 && !t.targeting.some((e) => k(e, n))) return !1;
-	let a = i ?? t.rollout ?? 100;
-	if (a < 100 && a > 0) {
-		if (!(D(e, j(t, n)) < a)) return !1;
-	} else if (a <= 0) return !1;
-	return !0;
-}, F = (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)));
-}, I = (e, t, n) => {
-	let r = t.variants ?? [];
-	if (r.length === 0) throw Error(`flag "${e}" has no variants`);
-	let i = O(e, j(t, n)), a = F(r);
-	for (let e = 0; e < r.length; e++) if (i < a[e]) return r[e];
-	return r[r.length - 1];
-}, L = (e, t, n, r = Date.now()) => {
-	let i = T(t), a = P(e, i, n, r);
-	if (!i.variants || i.variants.length === 0) return {
-		name: a ? "on" : "off",
-		value: a,
-		enabled: a
-	};
-	let o = I(e, i, n);
-	return {
-		name: o.name,
-		value: o.value,
-		enabled: a && o.name !== i.offVariant
-	};
-}, ee = (e, t, n = Date.now()) => {
-	let r = {};
-	for (let [i, a] of Object.entries(e)) r[i] = N(i, a, t, n);
-	return r;
-}, te = (e, t, n = Date.now()) => {
-	let r = {};
-	for (let [i, a] of Object.entries(e)) r[i] = L(i, a, t, n);
-	return r;
-}, R = "_voltro_feature_flag_audit", z = "_voltro_feature_flags", B = S(z, {
-	id: g({ prefix: "flag" }),
-	key: C().unique(),
-	enabled: p().default(!0),
-	rollout: _().nullable(),
-	rolloutBy: C().nullable(),
-	targeting: v().nullable(),
-	variants: v().nullable(),
-	offVariant: C().nullable(),
-	schedule: v().nullable(),
-	description: C().nullable(),
-	updatedAt: w().default("now").onUpdate("now")
-}), V = S(R, {
-	id: g({ prefix: "flagaud" }),
-	flag: C(),
-	enabled: p(),
-	previousEnabled: p().nullable(),
-	actorId: C().nullable(),
-	at: w().default("now")
-}).index("byFlagAuditFlag", ["flag"]).index("byFlagAuditAt", ["at"]), ne = (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;
-}, H = new class {
-	flags = {};
-	set(e) {
-		this.flags = e;
-	}
-	all() {
-		return this.flags;
-	}
-	get(e) {
-		return this.flags[e];
-	}
-}(), re = (e, t) => U(e, t) !== null, U = (e, t) => {
-	let n = H.get(e);
-	if (n === void 0) return null;
-	let r = T(n), i = r.enabled !== !1;
-	return H.set({
-		...H.all(),
-		[e]: {
-			...r,
-			enabled: t
-		}
-	}), i;
-}, W = (e) => Object.entries(e).map(([e, t]) => {
-	let n = T(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 = T(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(y(B).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 = G(t);
-		await e.upsert(z, n, { conflictColumns: ["key"] });
-	}
-}), G = (e) => ({
-	id: m("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(R, {
-			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 = y(V).orderBy("at", "desc");
-		return t?.flag != null && (n = n.where(h("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(z, {
-			...G(ie(t, n)),
-			id: m("flag", crypto.randomUUID())
-		}, { conflictColumns: ["key"] });
-		let a = (await e.query(y(B).where(h("key", t)).forUpdate().descriptor))[0];
-		if (!a) throw Error("flag override disappeared during toggle");
-		await e.update(z, 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()
-		});
-	});
-}, le = (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;
-}, ue = (e, t) => {
-	let n = le(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")}`);
-}, de = 864e5, K = (e) => typeof e == "number" ? e : Date.parse(e), fe = (e, t) => {
-	let n = T(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 >= K(r)) return {
-			shape: "expired",
-			reason: `schedule.deactivateAt (${String(r)}) has passed — the flag can never be on again`
-		};
-		if (e != null && t < K(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 < K(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(", ")})`
-	};
-}, pe = [
-	"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."
-], me = (e) => {
-	let t = e.now ?? Date.now(), n = e.staleAfterDays, r = t - n * de, 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) / de);
-	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 } = fe(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: pe
-	};
-}, q = "_voltro_feature_flag_usage", J = S(q, {
-	id: g({ prefix: "flagusg" }),
-	flag: C(),
-	day: C(),
-	source: C(),
-	lastAt: w()
-}).unique([
-	"flag",
-	"day",
-	"source"
-]).index("byFlagUsageLastAt", ["lastAt"]).index("byFlagUsageFlag", ["flag"]), he = (e) => e.toISOString().slice(0, 10), ge = (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");
-}, _e = (e, t, n) => `flagusg_${t.replace(/-/g, "")}_${n === "targeted" ? "t" : "b"}_${ge(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), ve = (e) => e === "bulk" ? "bulk" : "targeted", ye = (e) => ({
-	upsertMany: async (t) => {
-		for (let n of t) {
-			let t = he(n.lastAt);
-			await e.upsert(q, {
-				id: _e(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(y(J).descriptor)).map((e) => ({
-		flag: String(e.flag),
-		day: String(e.day),
-		source: ve(e.source),
-		lastAt: e.lastAt instanceof Date ? e.lastAt : new Date(String(e.lastAt))
-	}))
-}), be = 3e5, xe = (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());
-		}
-	};
-}, Se = (e = process.env, t = 90) => {
-	let n = x(e.VOLTRO_FLAG_USAGE_TTL_HOURS, 24 * t);
-	return b({
-		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 = H.get(t);
-	return X(t, "targeted"), n !== void 0 && N(t, n, Z(e));
-}, Ce = (e, t) => Q(e, t) ? l.void : l.fail(new c({ flag: t })), we = (e, t) => {
-	let n = H.get(t.key);
-	return X(t.key, "targeted"), n === void 0 ? t.defaultValue : i(t, L(t.key, n, Z(e)));
-}, Te = (e, t) => {
-	let n = H.get(t.key);
-	return X(t.key, "targeted"), n === void 0 ? null : L(t.key, n, Z(e)).name;
-}, Ee = (e, t) => e === t || e.startsWith("/") && e.endsWith("/") && new RegExp(e.slice(1, -1)).test(t), $ = e, De = (e = {}) => {
-	let i = e.gatedBy ?? {}, o = f({
-		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 ?? [], p = /* @__PURE__ */ new Map();
-	for (let t of s) {
-		if (p.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.`);
-		p.set(t.key, t);
-	}
-	s.some((e) => e.experiment !== void 0) && ue(s, e.experiments ?? []);
-	let m = { ...e.flags ?? {} };
-	for (let e of s) m[e.key] = e.definition;
-	let h = e.store === "postgres", g, _, v, y, b, x, S, C = [], w = e.usage ?? {}, T = w.track ?? h;
-	if (T && !h) 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 E = w.staleAfterDays ?? 30, D = w.retentionDays ?? 90;
-	if (E > D) throw Error(`${$}: usage.staleAfterDays (${E}) exceeds usage.retentionDays (${D}), so the observation window can never be long enough to prove a flag stale and every verdict would be withheld.`);
-	let O = (e) => {
-		let t = ne(m, e), n = [];
-		for (let [e, r] of p) {
+	}), 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);
 		}
-		C = n, H.set(t);
-	}, k = 0, A = async () => {
-		if (!_) return;
-		let e = ++k, t = await _.loadOverrides();
-		e === k && O(t);
-	}, j = async () => {
-		if (x && _) {
-			if (await A(), T && y && !b) {
-				S = Se(process.env, D), Y.enable();
-				let e = x.logger;
-				b = xe({
-					store: y,
-					intervalMs: w.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 C) x.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
 			});
 		}
-	}, M = (e) => {
-		if (i[e] !== void 0) return i[e];
-		for (let [t, n] of Object.entries(i)) if (t !== e && Ee(t, e)) return n;
-	}, N = (e, t) => {
-		let n = M(t.tag);
-		return n === void 0 || Q({ subject: t.subject }, n) ? e : l.fail(new c({ flag: n }));
-	}, P = Object.keys(i).length > 0, F = (e) => {
-		for (let t of e) X(t, "bulk");
-	}, I = {
+	}, 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 = H.all();
-			return F(Object.keys(e)), ee(e, t.request.subject ?? {});
+		execute: (e, t) => z.sync(() => {
+			let e = _.all();
+			return Z(Object.keys(e)), i(e, t.request.subject ?? {});
 		})
-	}, L = {
+	}, se = {
 		...n,
 		description: "Resolve every feature flag to its served variant for the calling subject.",
-		execute: (e, t) => l.sync(() => {
-			let e = H.all();
-			return F(Object.keys(e)), te(e, t.request.subject ?? {});
+		execute: (e, t) => z.sync(() => {
+			let e = _.all();
+			return Z(Object.keys(e)), a(e, t.request.subject ?? {});
 		})
-	}, R = (e) => ({
+	}, Q = (e) => ({
 		kind: "json",
 		data: e
-	}), z = (e, t) => ({
+	}), $ = (e, t) => ({
 		kind: "json",
 		status: e,
 		data: { error: t }
-	}), re = async () => {
+	}), ce = async () => {
 		let e = [];
-		if (T && y) try {
-			e = await y.load();
+		if (L && w) try {
+			e = await w.load();
 		} catch {
 			e = [];
 		}
-		return me({
-			flags: H.all(),
+		return D({
+			flags: _.all(),
 			usage: e,
-			tracking: T,
-			liveCounts: Y.liveTargetedCounts(),
-			staleAfterDays: E,
-			retentionDays: D
+			tracking: L,
+			liveCounts: j.liveTargetedCounts(),
+			staleAfterDays: V,
+			retentionDays: U
 		});
-	}, ie = () => {
+	}, le = () => {
 		let e = {};
-		for (let [t, n] of p) 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;
-	}, G = [
+	}, 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 re();
-				return R({
-					flags: W(H.all()),
-					writeScope: h ? "shared-store" : "process",
+			handler: () => z.promise(async () => {
+				let e = await ce();
+				return Q({
+					flags: f(_.all()),
+					writeScope: v ? "shared-store" : "process",
 					lifecycle: e,
-					typed: ie(),
-					overrideRefusals: C
+					typed: le(),
+					overrideRefusals: k
 				});
 			})
 		},
@@ -588,45 +138,45 @@ var T = (e) => typeof e == "boolean" ? { enabled: e } : e, E = (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 z(400, "invalid JSON body");
+					return $(400, "invalid JSON body");
 				}
-				if (!t || typeof t.key != "string" || !t.key || typeof t.enabled != "boolean") return z(400, "key (string) + enabled (boolean) required");
-				let n = t.key, r = t.enabled, i = H.get(n);
-				if (i === void 0) return z(404, `unknown flag "${n}"`);
-				if (h) {
-					let e = g;
-					if (!e) return z(503, "flag store is not ready");
-					let a = yield* l.tryPromise(async () => {
-						await ce(e, n, i, r, typeof t.actor == "string" ? t.actor : null), await A();
-					}).pipe(l.result);
-					if (u.isFailure(a)) return yield* l.tryPromise(A).pipe(l.ignore), z(503, "flag update could not be confirmed; reload the flag state before retrying");
-				} else U(n, r);
-				return R({
+				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: W(H.all())
+					flags: f(_.all())
 				});
 			})
 		},
 		{
 			method: "GET",
 			path: "/audit",
-			scope: h ? "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 (!v) return R({
+			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(() => v.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 R({ audit: a.map((e) => ({
+				return Q({ audit: a.map((e) => ({
 					flag: e.flag,
 					enabled: e.enabled,
 					previousEnabled: e.previousEnabled,
@@ -635,60 +185,60 @@ var T = (e) => typeof e == "boolean" ? { enabled: e } : e, E = (e, t) => {
 				})) });
 			})
 		}
-	], oe = [
-		...P ? [
+	], de = [
+		...X ? [
 			"rpc:intercept:mutation",
 			"rpc:intercept:query",
 			"rpc:intercept:action",
 			"rpc:intercept:workflow"
 		] : [],
-		...h ? ["store:write", "store:changes:read"] : [],
+		...v ? ["store:write", "store:changes:read"] : [],
 		"inspect:read",
 		"inspect:write"
 	];
-	return d({
-		name: o,
-		baseName: $,
+	return ne({
+		name: s,
+		baseName: K,
 		description: "Feature flags — targeting, % rollout, kill-switch, declarative gating + client evaluation.",
-		permissions: oe,
-		routes: [I, L],
+		permissions: de,
+		routes: [oe, se],
 		rpcClientDescriptors: r,
-		inspectEndpoints: G,
+		inspectEndpoints: ue,
 		errorSchemas: [{
-			schema: c,
+			schema: R,
 			import: {
 				module: "@voltro/plugin-flags/errors",
 				name: "FlagDisabled"
 			}
 		}],
-		...P ? {
-			interceptMutation: N,
-			interceptQuery: N,
-			interceptAction: N,
-			interceptWorkflow: N
+		...X ? {
+			interceptMutation: Y,
+			interceptQuery: Y,
+			interceptAction: Y,
+			interceptWorkflow: Y
 		} : {},
-		...h ? { extendSchema: { tables: T ? [
-			B,
-			V,
-			J
-		] : [B, V] } } : {},
-		...h ? { bindDataStore: async (e) => {
-			g = e, _ = ae(g), v = se(e), T && (y = ye(e)), await j();
+		...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();
 		} } : {},
-		...h ? { onChangeEvent: (e) => e.table === "_voltro_feature_flags" ? l.tryPromise(() => A()) : l.void } : {},
-		onActivate: (t) => l.gen(function* () {
-			H.set(m), x = t, _ && (yield* l.promise(j)), t.logger.info("feature flags active", {
-				count: Object.keys(m).length,
-				typed: p.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: T ? b ? `tracking (stale after ${E}d, observations kept ${Math.round((S ?? 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 () => {
-			x = void 0, await b?.stop(), b = void 0, Y.disable(), H.set({});
+		onDeactivate: () => z.promise(async () => {
+			E = void 0, await T?.stop(), T = void 0, j.disable(), _.set({});
 		})
 	});
 };
 //#endregion
-export { be as DEFAULT_FLAG_USAGE_FLUSH_MS, pe as FLAG_LIFECYCLE_LIMITS, q as FLAG_USAGE_TABLE, c as FlagDisabled, ue as assertFlagExperimentLinks, le as checkFlagExperimentLinks, fe as classifyShape, ye as dataStoreFlagUsageStore, s as defineFlag, W as describeFlags, ee as evaluateAll, te as evaluateAllVariants, N as evaluateFlag, M as evaluateSchedule, L as evaluateVariant, B as featureFlagsTable, V as flagAuditTable, me as flagLifecycleReport, H as flagRegistry, Y as flagUsageBuffer, _e as flagUsageRowId, J as flagUsageTable, we as flagValue, Te as flagVariant, De as flagsPlugin, U as flipFlagEnabled, a as gateOverride, Q as isFlagEnabled, o as isTypedFlag, ne as mergeOverrides, X as recordFlagEvaluation, Se as registerFlagUsageRetention, Ce as requireFlag, I as resolveVariant, re as setFlagEnabled, xe as startFlagUsageFlush, T as toDefinition, i as typedValueOf, he 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 };