@voltro/plugin-flags 0.85.0 → 0.87.0

package/dist/index.js

@@ -1,586 +1,275 @@
-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
+import { ConfigError as e, FlagDisabled as t, FlagToggleRefused as n } from "./errors.js";
+import { BASE_NAME as r, configMineDescriptor as i, configRpcClientImports as a, evaluateDescriptor as o, evaluateVariantsDescriptor as s, flagsRpcClientImports as ee } from "./rpc.js";
+import { evaluateAll as te, evaluateAllVariants as ne, evaluateFlag as c, evaluateSchedule as l, evaluateVariant as u, resolveVariant as d, toDefinition as re } from "./evaluate.js";
+import { dataStoreFlagAuditStore as ie, dataStoreFlagStore as ae, describeFlags as f, featureFlagsTable as p, flagAuditTable as m, flipFlagEnabled as oe, mergeOverrides as se, persistConfigValue as ce, persistFlagToggle as le, registry as h, setFlagEnabled as ue } from "./store.js";
+import { defineFlag as g, gateOverride as de, isTypedFlag as _, typedValueOf as v } from "./define.js";
+import { assertFlagExperimentLinks as y, checkFlagExperimentLinks as b } from "./experimentLink.js";
+import { FLAG_LIFECYCLE_LIMITS as x, classifyShape as S, flagLifecycleReport as fe } from "./lifecycle.js";
+import { DEFAULT_FLAG_USAGE_FLUSH_MS as C, FLAG_USAGE_TABLE as w, dataStoreFlagUsageStore as pe, flagUsageBuffer as T, flagUsageRowId as E, flagUsageTable as me, recordFlagEvaluation as D, registerFlagUsageRetention as he, startFlagUsageFlush as ge, utcDay as O } from "./usage.js";
+import { captureConfigFlag as _e, captureDefinedConfig as ve, configData as ye, configError as k, configKey as be, configSummary as xe, defineConfig as A } from "./config.js";
+import { ConfigPort as Se, captureConfigService as j, configValue as M, defaultConfigResolver as N, flagConfigService as Ce } from "./config-port.js";
+import { Effect as P, Layer as we, Result as Te } from "effect";
+import { definePlugin as Ee, pluginInstanceName as De } from "@voltro/protocol";
+//#region src/index.ts
+var F = (e) => "request" in e && e.request?.subject || "subject" in e && e.subject || {}, I = (e, t) => {
+	let n = h.get(t);
+	return D(t, "targeted"), n !== void 0 && c(t, n, F(e));
+}, L = (e, n) => I(e, n) ? P.void : P.fail(new t({ flag: n })), R = (e, t) => {
+	let n = h.get(t.key);
+	return D(t.key, "targeted"), n === void 0 ? t.defaultValue : v(t, u(t.key, n, F(e)));
+}, z = (e, t) => {
+	let n = h.get(t.key);
+	return D(t.key, "targeted"), n === void 0 ? null : u(t.key, n, F(e)).name;
+}, Oe = (e, t) => e === t || e.startsWith("/") && e.endsWith("/") && new RegExp(e.slice(1, -1)).test(t), B = r, V = (r = {}) => {
+	let c = [
+		"config",
+		"configVersion",
+		"configResolver",
+		"configService",
+		"configQuerySources"
+	], l = Object.create(null);
+	for (let e of c) {
+		let t = Object.getOwnPropertyDescriptor(r, e);
+		if (t) {
+			if (!("value" in t)) throw k("invalid_input");
+			l[e] = t.value;
 		}
-	}), 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 });
+	let u = Object.freeze(l), d = r.gatedBy ?? {}, ue = De({
+		base: B,
+		alias: r.alias,
+		instance: r.name
+	}), g = u.config === void 0 ? void 0 : ve(u.config);
+	if (g) {
+		if (ye(g, [
+			"entries",
+			"keys",
+			"typedFlags"
+		]), !Object.isFrozen(g) || !Object.isFrozen(g.entries) || !Array.isArray(g.keys) || g.keys.length < 1 || g.keys.length > 128) throw k("invalid_input");
+	} else if (u.configVersion !== void 0 || u.configResolver !== void 0 || u.configService !== void 0 || u.configQuerySources !== void 0) throw k("invalid_input");
+	let _ = be(u.configVersion ?? "default.v1");
+	if ((u.configResolver !== void 0 || u.configService !== void 0) && _ === "default.v1" || u.configService && u.configResolver) throw k("invalid_input");
+	let v;
+	if (u.configService) {
+		let e = u.configQuerySources;
+		if (!Array.isArray(e) || e.length > 32 || Reflect.ownKeys(e).length !== e.length + 1) throw k("invalid_input");
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = Object.getOwnPropertyDescriptor(e, String(n));
+			if (!r || !("value" in r) || typeof r.value != "string" || !/^[A-Za-z_][A-Za-z0-9_]{0,119}$/.test(r.value)) throw k("invalid_input");
+			t.push(r.value);
 		}
+		if (v = Object.freeze(t), new Set(v).size !== v.length) throw k("invalid_input");
+	} else if (u.configQuerySources !== void 0) throw k("invalid_input");
+	let b = new Set(g?.keys ?? []), x = [...r.typedFlags ?? [], ...u.configService ? [] : g?.typedFlags ?? []];
+	if (u.configService && (r.typedFlags?.some((e) => b.has(e.key)) || Object.keys(r.flags ?? {}).some((e) => b.has(e)))) throw k("invalid_input");
+	let S = /* @__PURE__ */ new Map();
+	for (let e of x) {
+		if (S.has(e.key)) throw Error(`${B}: two typedFlags declare the key ${JSON.stringify(e.key)}`);
+		if (r.flags?.[e.key] !== void 0) throw Error(`${B}: ${JSON.stringify(e.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.`);
+		S.set(e.key, e);
 	}
-	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"
-			] });
+	x.some((e) => e.experiment !== void 0) && y(x, r.experiments ?? []);
+	let C = { ...r.flags ?? {} };
+	for (let e of x) C[e.key] = e.definition;
+	let w = C, E = !1, O = 0, A = g ? Ce({
+		catalog: g,
+		flags: () => w,
+		active: () => E,
+		revision: () => O,
+		...u.configResolver === void 0 ? {} : { resolver: u.configResolver },
+		...u.configService === void 0 ? {} : { replacement: u.configService }
+	}) : void 0, j = () => g ? Object.fromEntries(Object.entries(h.all()).filter(([e]) => !b.has(e))) : h.all(), M = r.store === "postgres", F, L, R, z, V, H, ke, U = [], W = r.usage ?? {}, G = W.track ?? M;
+	if (G && !M) throw Error(`${B}: 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 K = W.staleAfterDays ?? 30, q = W.retentionDays ?? 90;
+	if (K > q) throw Error(`${B}: usage.staleAfterDays (${K}) exceeds usage.retentionDays (${q}), so the observation window can never be long enough to prove a flag stale and every verdict would be withheld.`);
+	let Ae = (e) => {
+		let t = se(C, e), n = g ? new Map(e.map((e) => [e.key, e])) : void 0, r = [];
+		for (let [e, i] of S) {
+			let a = t[e];
+			if (a === void 0) continue;
+			if (g && b.has(e)) try {
+				let r = n?.get(e), i = r ? {
+					enabled: r.enabled,
+					...Object.fromEntries([
+						"rollout",
+						"rolloutBy",
+						"targeting",
+						"variants",
+						"offVariant",
+						"schedule",
+						"description"
+					].flatMap((e) => {
+						let t = r[e];
+						return t === null ? [] : [[e, t]];
+					}))
+				} : a;
+				a = _e(g.entries[e], i), t[e] = a;
+			} catch {
+				r.push({
+					key: e,
+					reason: "Override does not satisfy the bounded Config contract"
+				}), t[e] = i.definition;
+				continue;
+			}
+			let o = de(i, typeof a == "boolean" ? { enabled: a } : a);
+			o.ok || (r.push(o.refusal), t[e] = i.definition);
 		}
-	},
-	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
+		U = r, g && (w = t), h.set(t);
+	}, J = 0, Y = async () => {
+		if (!L) return;
+		let e = ++J, t = await L.loadOverrides();
+		e === J && Ae(t);
+	}, je = (t) => P.suspend(() => {
+		let n = g && typeof t?.key == "string" && b.has(t.key) ? g.entries[t.key] : void 0;
+		if (!g || !n) return P.fail(new e({ code: "not_found" }));
+		let r;
+		try {
+			r = _e(n, {
+				enabled: !0,
+				rollout: 100,
+				variants: [{
+					name: "set",
+					value: t.value
+				}]
 			});
+		} catch {
+			return P.fail(new e({ code: "invalid_value" }));
 		}
-	}, 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: $,
-		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) {
-			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);
-		}
-		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,
+		let i = n.key, a = r.variants[0].value;
+		if (!M) return w = {
+			...w,
+			[i]: r
+		}, O++, h.set({
+			...h.all(),
+			[i]: r
+		}), P.succeed({
+			key: i,
+			value: a
+		});
+		let o = F, s = h.get(i);
+		return !o || s === void 0 ? P.fail(new e({ code: "unavailable" })) : P.tryPromise(async () => {
+			await ce(o, i, s, a, typeof t.actor == "string" ? t.actor : null), await Y();
+		}).pipe(P.as({
+			key: i,
+			value: a
+		}), P.catch(() => P.tryPromise(Y).pipe(P.ignore, P.andThen(P.fail(new e({ code: "unavailable" }))))));
+	}), X = (e) => P.suspend(() => {
+		let t = e.key, r = e.enabled, i = (e) => P.fail(new n({
+			key: t,
+			reason: e
+		}));
+		if (typeof t != "string" || !t || typeof r != "boolean") return i("unknown_flag");
+		if (b.has(t)) return i("config_value");
+		let a = h.get(t);
+		if (a === void 0) return i("unknown_flag");
+		let o = re(a).enabled !== !1;
+		if (!M) return oe(t, r), P.succeed({
+			key: t,
+			enabled: r,
+			previous: o
+		});
+		let s = F;
+		return s ? P.tryPromise(async () => {
+			await le(s, t, a, r, typeof e.actor == "string" ? e.actor : null), await Y();
+		}).pipe(P.as({
+			key: t,
+			enabled: r,
+			previous: o
+		}), P.catch(() => P.tryPromise(Y).pipe(P.ignore, P.andThen(i("unconfirmed"))))) : i("not_ready");
+	}), Me = async () => {
+		if (H && L) {
+			if (await Y(), G && z && !V) {
+				ke = he(process.env, q), T.enable();
+				let e = H.logger;
+				V = ge({
+					store: z,
+					intervalMs: W.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 U) H.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 = {
-		...t,
+	}, Ne = (e) => {
+		if (d[e] !== void 0) return d[e];
+		for (let [t, n] of Object.entries(d)) if (t !== e && Oe(t, e)) return n;
+	}, Z = (e, n) => {
+		let r = Ne(n.tag);
+		return r === void 0 || I({ subject: n.subject }, r) ? e : P.fail(new t({ flag: r }));
+	}, Pe = Object.keys(d).length > 0, Fe = (e) => {
+		for (let t of e) D(t, "bulk");
+	}, Ie = {
+		...o,
 		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) => P.sync(() => {
+			let e = j();
+			return Fe(Object.keys(e)), te(e, t.request.subject ?? {});
 		})
-	}, L = {
-		...n,
+	}, Le = {
+		...s,
 		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) => P.sync(() => {
+			let e = j();
+			return Fe(Object.keys(e)), ne(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 () => {
+	}), Re = async () => {
 		let e = [];
-		if (T && y) try {
-			e = await y.load();
+		if (G && z) try {
+			e = await z.load();
 		} catch {
 			e = [];
 		}
-		return me({
-			flags: H.all(),
+		return fe({
+			flags: j(),
 			usage: e,
-			tracking: T,
-			liveCounts: Y.liveTargetedCounts(),
-			staleAfterDays: E,
-			retentionDays: D
+			tracking: G,
+			liveCounts: T.liveTargetedCounts(),
+			staleAfterDays: K,
+			retentionDays: q
 		});
-	}, ie = () => {
+	}, ze = () => {
 		let e = {};
-		for (let [t, n] of p) e[t] = {
+		for (let [t, n] of S) b.has(t) || (e[t] = {
 			valueType: n.valueType,
 			variants: n.variants.map((e) => e.name),
 			experiment: n.experiment ?? null
-		};
+		});
 		return e;
-	}, G = [
+	}, Be = [
 		{
 			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: () => P.promise(async () => {
+				let e = await Re();
+				return Q({
+					flags: f(j()),
+					writeScope: M ? "shared-store" : "process",
 					lifecycle: e,
-					typed: ie(),
-					overrideRefusals: C
+					typed: ze(),
+					overrideRefusals: U,
+					...g ? { config: {
+						bound: E,
+						backend: u.configService ? "custom" : "flags",
+						version: _,
+						resolver: u.configService ? "app-owned" : (u.configResolver ?? N) === N ? "default" : "custom",
+						keys: xe(g),
+						publicKeys: g.keys.filter((e) => g.entries[e].public),
+						maxValueBytes: 16384,
+						roomBindingInstalled: !1,
+						gmEditInstalled: !1
+					} } : {}
 				});
 			})
 		},
@@ -588,45 +277,44 @@ 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) => P.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 $(400, "key (string) + enabled (boolean) required");
+				let n = yield* P.result(X({
+					key: t.key,
+					enabled: t.enabled,
+					actor: typeof t.actor == "string" ? t.actor : null
+				}));
+				if (Te.isFailure(n)) {
+					let e = n.failure.reason;
+					return e === "config_value" ? $(400, "Config values require their typed writer; the flag toggle cannot change them") : e === "unknown_flag" ? $(404, `unknown flag "${t.key}"`) : e === "not_ready" ? $(503, "flag store is not ready") : $(503, "flag update could not be confirmed; reload the flag state before retrying");
 				}
-				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({
+				return Q({
 					ok: !0,
-					flags: W(H.all())
+					flags: f(j())
 				});
 			})
 		},
 		{
 			method: "GET",
 			path: "/audit",
-			scope: h ? "shared-store" : "declaration",
+			scope: M ? "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) => P.gen(function* () {
+				if (!R) 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* P.promise(() => R.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 +323,93 @@ var T = (e) => typeof e == "boolean" ? { enabled: e } : e, E = (e, t) => {
 				})) });
 			})
 		}
-	], oe = [
-		...P ? [
+	], Ve = [
+		...Pe ? [
 			"rpc:intercept:mutation",
 			"rpc:intercept:query",
 			"rpc:intercept:action",
 			"rpc:intercept:workflow"
 		] : [],
-		...h ? ["store:write", "store:changes:read"] : [],
+		...M ? ["store:write", "store:changes:read"] : [],
 		"inspect:read",
 		"inspect:write"
 	];
-	return d({
-		name: o,
-		baseName: $,
-		description: "Feature flags — targeting, % rollout, kill-switch, declarative gating + client evaluation.",
-		permissions: oe,
-		routes: [I, L],
-		rpcClientDescriptors: r,
-		inspectEndpoints: G,
-		errorSchemas: [{
-			schema: c,
-			import: {
-				module: "@voltro/plugin-flags/errors",
-				name: "FlagDisabled"
-			}
-		}],
-		...P ? {
-			interceptMutation: N,
-			interceptQuery: N,
-			interceptAction: N,
-			interceptWorkflow: N
+	return {
+		toggle: X,
+		...A ? {
+			config: () => A,
+			setConfig: je
 		} : {},
-		...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();
-		} } : {},
-		...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,
-				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"
-			});
-		}),
-		onDeactivate: () => l.promise(async () => {
-			x = void 0, await b?.stop(), b = void 0, Y.disable(), H.set({});
+		...Ee({
+			name: ue,
+			baseName: B,
+			description: "Feature flags — targeting, % rollout, kill-switch, declarative gating + client evaluation.",
+			permissions: Ve,
+			routes: [
+				Ie,
+				Le,
+				...A ? [{
+					...i,
+					...v === void 0 ? {} : { source: v },
+					execute: (e, t) => A.mine(t.request.subject)
+				}] : []
+			],
+			rpcClientDescriptors: [...ee, ...A ? a : []],
+			inspectEndpoints: Be,
+			errorSchemas: [{
+				schema: t,
+				import: {
+					module: "@voltro/plugin-flags/errors",
+					name: "FlagDisabled"
+				}
+			}, ...A ? [{
+				schema: e,
+				import: {
+					module: "@voltro/plugin-flags/errors",
+					name: "ConfigError"
+				}
+			}] : []],
+			...A ? { services: we.succeed(Se, A) } : {},
+			...Pe ? {
+				interceptMutation: Z,
+				interceptQuery: Z,
+				interceptAction: Z,
+				interceptWorkflow: Z
+			} : {},
+			...M ? { extendSchema: { tables: G ? [
+				p,
+				m,
+				me
+			] : [p, m] } } : {},
+			...M ? { bindDataStore: async (e) => {
+				F = e, L = ae(F), R = ie(e), G && (z = pe(e)), await Me();
+			} } : {},
+			...M ? { onChangeEvent: (e) => e.table === "_voltro_feature_flags" ? P.tryPromise(() => Y()) : P.void } : {},
+			onActivate: (e) => P.gen(function* () {
+				g && (E = !1, O++, J++, w = C), h.set(C), H = e, L && (yield* P.promise(Me)), g && (E = !0), e.logger.info("feature flags active", {
+					count: Object.keys(C).length,
+					typed: S.size,
+					gated: Object.keys(d).length,
+					store: r.store ?? "memory",
+					usage: G ? V ? `tracking (stale after ${K}d, observations kept ${Math.round((ke ?? 0) / 864e5)}d)` : "waiting for store binding" : "off — no dead-flag evidence is collected"
+				});
+			}),
+			onDeactivate: () => P.promise(async () => {
+				g && (E = !1, O++, J++), H = void 0, await V?.stop(), V = void 0, T.disable(), h.set({});
+			})
 		})
-	});
-};
+	};
+}, H = Object.freeze({
+	slots: { resolver: {
+		defaultExport: "defaultConfigResolver",
+		fixtureExport: "configResolverSystemFixture"
+	} },
+	ports: { config: {
+		tagExport: "ConfigPort",
+		fakeLayerExport: "configFakeLayer",
+		fixtureExport: "configPortSystemFixture"
+	} },
+	events: []
+});
 //#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 { e as ConfigError, Se as ConfigPort, C as DEFAULT_FLAG_USAGE_FLUSH_MS, x as FLAG_LIFECYCLE_LIMITS, w as FLAG_USAGE_TABLE, t as FlagDisabled, y as assertFlagExperimentLinks, j as captureConfigService, b as checkFlagExperimentLinks, S as classifyShape, xe as configSummary, H as configSystemContract, M as configValue, pe as dataStoreFlagUsageStore, N as defaultConfigResolver, A as defineConfig, g as defineFlag, f as describeFlags, te as evaluateAll, ne as evaluateAllVariants, c as evaluateFlag, l as evaluateSchedule, u as evaluateVariant, p as featureFlagsTable, m as flagAuditTable, Ce as flagConfigService, fe as flagLifecycleReport, h as flagRegistry, T as flagUsageBuffer, E as flagUsageRowId, me as flagUsageTable, R as flagValue, z as flagVariant, V as flagsPlugin, oe as flipFlagEnabled, de as gateOverride, I as isFlagEnabled, _ as isTypedFlag, se as mergeOverrides, D as recordFlagEvaluation, he as registerFlagUsageRetention, L as requireFlag, d as resolveVariant, ue as setFlagEnabled, ge as startFlagUsageFlush, re as toDefinition, v as typedValueOf, O as utcDay };