@burdenoff/fe-libs 2026.510.126

package/dist/shared/events/sinks/BackendAuditSink.js

@@ -0,0 +1,50 @@
+"use client";
+import { useEventBus as e } from "../../../shared-events.js";
+import { useEffect as t, useRef as n } from "react";
+//#region src/shared/events/sinks/BackendAuditSink.tsx
+var r = [
+	"audit.",
+	"auth.",
+	"security."
+], i = /(token|password|secret|authorization|cookie|session|stack)/i;
+function a(e, t) {
+	return t?.includes(e.name) ? !0 : r.some((t) => e.name.startsWith(t));
+}
+function o(e, t) {
+	return e && i.test(e) ? "[REDACTED]" : Array.isArray(t) ? t.map((e) => o(void 0, e)) : t && typeof t == "object" ? Object.fromEntries(Object.entries(t).map(([e, t]) => [e, o(e, t)])) : t;
+}
+function s(e) {
+	return o(void 0, e);
+}
+function c({ endpoint: r, flushInterval: i = 3e3, batchSize: o = 20, allowlist: c }) {
+	let l = e(), u = n([]);
+	return t(() => l.onAny((e) => {
+		a(e, c) && (u.current = [...u.current, s(e)]);
+	}), [c, l]), t(() => {
+		let e = async () => {
+			if (u.current.length === 0) return;
+			let e = u.current.splice(0, o);
+			try {
+				await fetch(r, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ events: e }),
+					keepalive: !0
+				});
+			} catch {}
+		}, t = () => {
+			if (u.current.length === 0) return;
+			let t = u.current.splice(0, o), n = JSON.stringify({ events: t }), i = new Blob([n], { type: "application/json" });
+			navigator.sendBeacon(r, i) || e();
+		}, n = setInterval(e, i);
+		return window.addEventListener("pagehide", t), () => {
+			clearInterval(n), window.removeEventListener("pagehide", t);
+		};
+	}, [
+		r,
+		i,
+		o
+	]), null;
+}
+//#endregion
+export { c as BackendAuditSink };

package/dist/shared/events/sinks/BroadcastChannelSink.d.ts

@@ -0,0 +1,10 @@
+interface BroadcastChannelSinkProps {
+    channelName?: string;
+}
+/**
+ * BroadcastChannelSink relays every event bus emission to a BroadcastChannel
+ * so other tabs/windows of the same origin receive the events.
+ */
+export declare function BroadcastChannelSink({ channelName, }: BroadcastChannelSinkProps): null;
+export {};
+//# sourceMappingURL=BroadcastChannelSink.d.ts.map

package/dist/shared/events/sinks/BroadcastChannelSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastChannelSink.d.ts","sourceRoot":"","sources":["../../../../src/shared/events/sinks/BroadcastChannelSink.tsx"],"names":[],"mappings":"AAKA,UAAU,yBAAyB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,WAAgC,GACjC,EAAE,yBAAyB,QAoB3B"}

package/dist/shared/events/sinks/BroadcastChannelSink.js

@@ -0,0 +1,20 @@
+"use client";
+import { useEventBus as e } from "../../../shared-events.js";
+import { useEffect as t } from "react";
+//#region src/shared/events/sinks/BroadcastChannelSink.tsx
+function n({ channelName: n = "burdenoff-events" }) {
+	let r = e();
+	return t(() => {
+		if (typeof BroadcastChannel > "u") return;
+		let e = new BroadcastChannel(n), t = r.onAny((t) => {
+			try {
+				e.postMessage(t);
+			} catch {}
+		});
+		return () => {
+			t(), e.close();
+		};
+	}, [r, n]), null;
+}
+//#endregion
+export { n as BroadcastChannelSink };

package/dist/shared/events/sinks/DevtoolsSink.d.ts

@@ -0,0 +1,10 @@
+interface DevtoolsSinkProps {
+    enabled?: boolean;
+}
+/**
+ * DevtoolsSink logs every event bus emission to the browser console.
+ * Render inside EventBusProvider. Typically enabled only in development.
+ */
+export declare function DevtoolsSink({ enabled }: DevtoolsSinkProps): null;
+export {};
+//# sourceMappingURL=DevtoolsSink.d.ts.map

package/dist/shared/events/sinks/DevtoolsSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevtoolsSink.d.ts","sourceRoot":"","sources":["../../../../src/shared/events/sinks/DevtoolsSink.tsx"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAc,EAAE,EAAE,iBAAiB,QAgBjE"}

package/dist/shared/events/sinks/DevtoolsSink.js

@@ -0,0 +1,18 @@
+"use client";
+import { useEventBus as e } from "../../../shared-events.js";
+import { useEffect as t } from "react";
+//#region src/shared/events/sinks/DevtoolsSink.tsx
+function n({ enabled: n = !0 }) {
+	let r = e();
+	return t(() => {
+		if (n) return r.onAny((e) => {
+			console.debug(`%c[EventBus] ${e.name}`, "color: #6366f1; font-weight: bold;", e.payload, {
+				id: e.id,
+				source: e.source,
+				ts: e.timestamp
+			});
+		});
+	}, [r, n]), null;
+}
+//#endregion
+export { n as DevtoolsSink };

package/dist/shared/events/sinks/OtelBrowserSink.d.ts

@@ -0,0 +1,14 @@
+interface OtelBrowserSinkProps {
+    endpoint: string | undefined;
+    /** Service name for OTLP resource. Default "frontend". */
+    serviceName?: string;
+    /** How long to wait before flushing spans (ms). Default 5000. */
+    flushInterval?: number;
+}
+/**
+ * OtelBrowserSink forwards event bus emissions as OTLP/HTTP trace spans.
+ * Uses fetch to POST to the configured OpenTelemetry collector endpoint.
+ */
+export declare function OtelBrowserSink({ endpoint, serviceName, flushInterval, }: OtelBrowserSinkProps): null;
+export {};
+//# sourceMappingURL=OtelBrowserSink.d.ts.map

package/dist/shared/events/sinks/OtelBrowserSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OtelBrowserSink.d.ts","sourceRoot":"","sources":["../../../../src/shared/events/sinks/OtelBrowserSink.tsx"],"names":[],"mappings":"AAMA,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAiED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,WAAwB,EACxB,aAAoB,GACrB,EAAE,oBAAoB,QAmDtB"}

package/dist/shared/events/sinks/OtelBrowserSink.js

@@ -0,0 +1,92 @@
+"use client";
+import { createBrowserTraceContext as e } from "../metadata.js";
+import { useEventBus as t } from "../../../shared-events.js";
+import { useEffect as n, useRef as r } from "react";
+//#region src/shared/events/sinks/OtelBrowserSink.tsx
+function i(e) {
+	return e.name.startsWith("error.") || e.name.startsWith("perf.") || e.name === "nav.route.changed";
+}
+function a(t, n) {
+	let r = BigInt(Date.now()) * 1000000n, i = e();
+	return {
+		traceId: t.metadata.traceId ?? i.traceId,
+		spanId: t.metadata.spanId ?? i.spanId,
+		name: t.name,
+		kind: 3,
+		startTimeUnixNano: String(r - 1000000n),
+		endTimeUnixNano: String(r),
+		attributes: [
+			{
+				key: "event.name",
+				value: { stringValue: t.name }
+			},
+			{
+				key: "event.source.mfe",
+				value: { stringValue: t.source?.mfe ?? n }
+			},
+			{
+				key: "app.name",
+				value: { stringValue: t.metadata.app.name ?? n }
+			},
+			{
+				key: "app.env",
+				value: { stringValue: t.metadata.app.env ?? "unknown" }
+			},
+			{
+				key: "burdenoff.route",
+				value: { stringValue: t.metadata.route.pathname }
+			}
+		],
+		status: { code: t.name.startsWith("error.") ? 2 : 1 }
+	};
+}
+function o(e, t) {
+	return { resourceSpans: [{
+		resource: { attributes: [{
+			key: "service.name",
+			value: { stringValue: t }
+		}, {
+			key: "service.namespace",
+			value: { stringValue: "frontend" }
+		}] },
+		scopeSpans: [{
+			scope: { name: "burdenoff.event-bus" },
+			spans: e.map((e) => a(e, t))
+		}]
+	}] };
+}
+function s({ endpoint: e, serviceName: a = "frontend", flushInterval: s = 5e3 }) {
+	let c = t(), l = r([]);
+	return n(() => {
+		if (e) return c.onAny((e) => {
+			i(e) && (l.current = [...l.current, e]);
+		});
+	}, [c, e]), n(() => {
+		if (!e) return;
+		let t = async () => {
+			if (l.current.length === 0) return;
+			let t = o(l.current.splice(0, 50), a);
+			try {
+				await fetch(`${e}/v1/traces`, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify(t),
+					keepalive: !0
+				});
+			} catch {}
+		}, n = () => {
+			if (l.current.length === 0) return;
+			let n = l.current.splice(0, 50), r = JSON.stringify(o(n, a)), i = new Blob([r], { type: "application/json" });
+			navigator.sendBeacon(`${e}/v1/traces`, i) || t();
+		}, r = setInterval(t, s);
+		return window.addEventListener("pagehide", n), () => {
+			clearInterval(r), window.removeEventListener("pagehide", n);
+		};
+	}, [
+		e,
+		a,
+		s
+	]), null;
+}
+//#endregion
+export { s as OtelBrowserSink };

package/dist/shared/events/sinks/RybbitSink.d.ts

@@ -0,0 +1,18 @@
+import { BurdenoffEventName } from '../index';
+interface RybbitSinkProps {
+    siteId: string | undefined;
+    scriptUrl?: string;
+    /** Map event bus names to Rybbit event names. Defaults to identity. */
+    rename?: Partial<Record<BurdenoffEventName, string>>;
+    /** Only forward these event names to Rybbit. Defaults to a minimal privacy-safe list. */
+    allowlist?: BurdenoffEventName[];
+    /** Which event triggers `rybbit.identify`. */
+    identifyOn?: BurdenoffEventName;
+}
+/**
+ * RybbitSink injects the Rybbit analytics script and forwards matching
+ * event bus emissions as Rybbit custom events.
+ */
+export declare function RybbitSink({ siteId, scriptUrl, rename, allowlist, identifyOn, }: RybbitSinkProps): null;
+export {};
+//# sourceMappingURL=RybbitSink.d.ts.map

package/dist/shared/events/sinks/RybbitSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RybbitSink.d.ts","sourceRoot":"","sources":["../../../../src/shared/events/sinks/RybbitSink.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAmBhE,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,yFAAyF;IACzF,SAAS,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACjC,8CAA8C;IAC9C,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAyDD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,SAA2D,EAC3D,MAAW,EACX,SAAoC,EACpC,UAA6B,GAC9B,EAAE,eAAe,QA0DjB"}

package/dist/shared/events/sinks/RybbitSink.js

@@ -0,0 +1,85 @@
+"use client";
+import { useEventBus as e } from "../../../shared-events.js";
+import { useEffect as t, useRef as n } from "react";
+//#region src/shared/events/sinks/RybbitSink.tsx
+var r = [
+	"nav.route.changed",
+	"auth.signed_in",
+	"auth.signed_out"
+], i = /(token|password|secret|authorization|cookie|session|email|name|stack|message)/i;
+function a() {
+	let e = window;
+	return navigator.doNotTrack === "1" || e.doNotTrack === "1";
+}
+function o(e) {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n += 1) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
+	return `u_${(t >>> 0).toString(16).padStart(8, "0")}`;
+}
+async function s(e) {
+	if (crypto.subtle) {
+		let t = new TextEncoder().encode(e), n = await crypto.subtle.digest("SHA-256", t);
+		return Array.from(new Uint8Array(n), (e) => e.toString(16).padStart(2, "0")).join("");
+	}
+	return o(e);
+}
+function c(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return {};
+	let t = {};
+	for (let [n, r] of Object.entries(e)) i.test(n) || (typeof r == "string" || typeof r == "number" || typeof r == "boolean") && (t[n] = r);
+	return t;
+}
+function l(e) {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) {
+		let e = {
+			...t,
+			[n]: r
+		};
+		if (JSON.stringify(e).length > 1024) break;
+		t[n] = r;
+	}
+	return t;
+}
+function u({ siteId: i, scriptUrl: o = "https://analytics.burdenoff.com/api/script.js", rename: u = {}, allowlist: d = r, identifyOn: f = "auth.signed_in" }) {
+	let p = e(), m = n(!1);
+	return t(() => {
+		if (!i || m.current) return;
+		m.current = !0;
+		let e = document.createElement("script");
+		return e.src = o, e.defer = !0, e.dataset.siteId = i, document.head.appendChild(e), () => {
+			document.head.removeChild(e);
+		};
+	}, [i, o]), t(() => {
+		if (i) return p.onAny((e) => {
+			if (a()) return;
+			let t = window;
+			if (!t.rybbit || !d.includes(e.name)) return;
+			let n = l({
+				route: e.metadata.route.pathname,
+				env: e.metadata.app.env,
+				...c(e.payload)
+			});
+			if (e.name === f) {
+				let r = e.payload, i = r?.userId ?? r?.actorId ?? r?.id;
+				i && s(i).then((e) => {
+					t.rybbit?.identify(e, n);
+				});
+			}
+			if (e.name === "nav.route.changed") {
+				t.rybbit.pageview();
+				return;
+			}
+			let r = u[e.name] ?? e.name;
+			t.rybbit.event(r, n);
+		});
+	}, [
+		p,
+		i,
+		d,
+		f,
+		u
+	]), null;
+}
+//#endregion
+export { u as RybbitSink };

package/dist/shared/events/sinks/index.d.ts

@@ -0,0 +1,6 @@
+export { DevtoolsSink } from './DevtoolsSink';
+export { BroadcastChannelSink } from './BroadcastChannelSink';
+export { BackendAuditSink } from './BackendAuditSink';
+export { RybbitSink } from './RybbitSink';
+export { OtelBrowserSink } from './OtelBrowserSink';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/events/sinks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/events/sinks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/shared/events/sinks/index.js

@@ -0,0 +1,5 @@
+import "./DevtoolsSink.js";
+import "./BroadcastChannelSink.js";
+import "./BackendAuditSink.js";
+import "./RybbitSink.js";
+import "./OtelBrowserSink.js";

package/dist/shared/feature-flags/FeatureFlagProvider.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode } from 'react';
+import { FeatureFlagContextValue, FeatureFlagProviderConfig } from './types';
+export interface FeatureFlagProviderProps extends FeatureFlagProviderConfig {
+    children: ReactNode;
+}
+/**
+ * FeatureFlagProvider — manages feature flag state for UI components.
+ *
+ * Evaluates feature flags against the backend for the given workspace context.
+ * When workspaceId is null (not in a workspace), flags are not fetched and
+ * all flags return the default-allow value (true).
+ *
+ * @example
+ * ```tsx
+ * // In your app shell
+ * <FeatureFlagProvider workspaceId={activeWorkspaceId} refreshInterval={60000}>
+ *   <App />
+ * </FeatureFlagProvider>
+ *
+ * // In components
+ * const { isEnabled } = useFeatureFlags();
+ * if (isEnabled('new-dashboard')) {
+ *   return <NewDashboard />;
+ * }
+ * ```
+ */
+export declare function FeatureFlagProvider({ children, workspaceId, gateway, flagKeys, refreshInterval, // 5 minutes
+staleTime, // 5 minutes
+debug, defaultEnabled, }: FeatureFlagProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the feature flag context.
+ *
+ * @throws Error if used outside a FeatureFlagProvider.
+ *
+ * @example
+ * ```tsx
+ * const { isEnabled, getValue, isLoading } = useFeatureFlags();
+ *
+ * if (isLoading) return <Spinner />;
+ *
+ * if (isEnabled('new-dashboard')) {
+ *   return <NewDashboard />;
+ * }
+ * ```
+ */
+export declare function useFeatureFlags(): FeatureFlagContextValue;
+//# sourceMappingURL=FeatureFlagProvider.d.ts.map

package/dist/shared/feature-flags/FeatureFlagProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureFlagProvider.d.ts","sourceRoot":"","sources":["../../../src/shared/feature-flags/FeatureFlagProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EAGV,uBAAuB,EACvB,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AA+BjB,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB;IACzE,QAAQ,EAAE,SAAS,CAAC;CACrB;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,WAAW,EACX,OAAkB,EAClB,QAAQ,EACR,eAA+B,EAAE,YAAY;AAC7C,SAAyB,EAAE,YAAY;AACvC,KAAa,EACb,cAAqB,GACtB,EAAE,wBAAwB,2CAoO1B;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,IAAI,uBAAuB,CAQzD"}

package/dist/shared/feature-flags/FeatureFlagProvider.js

@@ -0,0 +1,110 @@
+import { graphqlFetch as e } from "../graphql/fetch.js";
+import { createContext as t, useCallback as n, useContext as r, useEffect as i, useMemo as a, useRef as o, useState as s } from "react";
+import { jsx as c } from "react/jsx-runtime";
+//#region src/shared/feature-flags/FeatureFlagProvider.tsx
+var l = "\n  query EvaluateFeatureFlags($input: EvaluateFeatureFlagsInput!) {\n    evaluateFeatureFlags(input: $input) {\n      evaluations {\n        key\n        value\n        variant\n        reason\n        flagType\n        errorCode\n      }\n    }\n  }\n", u = t(null);
+function d({ children: t, workspaceId: r, gateway: d = "global", flagKeys: f, refreshInterval: p = 300 * 1e3, staleTime: m = 300 * 1e3, debug: h = !1, defaultEnabled: g = !0 }) {
+	let [_, v] = s(/* @__PURE__ */ new Map()), [y, b] = s(!1), [x, S] = s(null), C = o(0), w = o(null), T = n(async (t = !1) => {
+		if (!r) {
+			h && console.log("[FeatureFlagProvider] No workspaceId, skipping fetch"), v(/* @__PURE__ */ new Map()), S(null);
+			return;
+		}
+		if (!t && Date.now() - C.current < m) {
+			h && console.log("[FeatureFlagProvider] Data still fresh, skipping fetch");
+			return;
+		}
+		w.current && w.current.abort();
+		let n = new AbortController();
+		w.current = n, b(!0);
+		try {
+			h && console.log("[FeatureFlagProvider] Fetching flags for workspace:", r);
+			let t = await e({
+				gateway: d,
+				query: l,
+				variables: { input: {
+					workspaceId: r,
+					...f && f.length > 0 ? { keys: f } : {}
+				} },
+				operationName: "EvaluateFeatureFlags",
+				signal: n.signal
+			});
+			if (n.signal.aborted) return;
+			if (t.errors?.length) {
+				let e = t.errors[0].message;
+				throw h && console.error("[FeatureFlagProvider] GraphQL errors:", t.errors), Error(e);
+			}
+			let i = t.data?.evaluateFeatureFlags?.evaluations ?? [], a = /* @__PURE__ */ new Map();
+			for (let e of i) a.set(e.key, e);
+			v(a), S(null), C.current = Date.now(), h && console.log("[FeatureFlagProvider] Loaded", a.size, "flags:", Object.fromEntries(a));
+		} catch (e) {
+			if (e instanceof Error && e.name === "AbortError") return;
+			let t = e instanceof Error ? e : Error(String(e));
+			S(t), h && console.error("[FeatureFlagProvider] Fetch error:", t);
+		} finally {
+			n.signal.aborted || b(!1);
+		}
+	}, [
+		r,
+		d,
+		f,
+		m,
+		h
+	]);
+	i(() => (C.current = 0, T(!0), () => {
+		w.current && w.current.abort();
+	}), [T]), i(() => {
+		if (!p || p <= 0 || !r) return;
+		let e = setInterval(() => {
+			T(!0);
+		}, p);
+		return () => clearInterval(e);
+	}, [
+		p,
+		r,
+		T
+	]);
+	let E = n((e) => {
+		let t = _.get(e);
+		return t ? (t.flagType, !!t.value) : g;
+	}, [_, g]), D = n((e, t) => {
+		let n = _.get(e);
+		return n ? n.value : t;
+	}, [_]), O = n((e) => _.get(e), [_]), k = n(() => {
+		let e = {};
+		for (let [t, n] of _) e[t] = n.value;
+		return e;
+	}, [_]), A = n(async () => {
+		h && console.log("[FeatureFlagProvider] Manual refresh requested"), await T(!0);
+	}, [T, h]), j = a(() => ({
+		evaluations: _,
+		isLoading: y,
+		error: x,
+		isEnabled: E,
+		getValue: D,
+		getEvaluation: O,
+		getAllFlags: k,
+		refreshFlags: A,
+		workspaceId: r
+	}), [
+		_,
+		y,
+		x,
+		E,
+		D,
+		O,
+		k,
+		A,
+		r
+	]);
+	return /* @__PURE__ */ c(u.Provider, {
+		value: j,
+		children: t
+	});
+}
+function f() {
+	let e = r(u);
+	if (!e) throw Error("useFeatureFlags must be used within a FeatureFlagProvider");
+	return e;
+}
+//#endregion
+export { d as FeatureFlagProvider, f as useFeatureFlags };

package/dist/shared/feature-flags/FeatureGate.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+export interface FeatureGateProps {
+    /** Feature flag key to check */
+    flag: string;
+    /** Content to render when the flag is enabled (or disabled if inverted) */
+    children: ReactNode;
+    /** Content to render when the flag is disabled (or enabled if inverted) */
+    fallback?: ReactNode;
+    /** Content to render while flags are loading */
+    loading?: ReactNode;
+    /**
+     * Invert the check: render children when the flag is DISABLED.
+     * Useful for showing legacy UI until a new feature is enabled.
+     * @default false
+     */
+    invert?: boolean;
+    /**
+     * Default value if the flag is not found.
+     * @default true (default-allow)
+     */
+    defaultValue?: boolean;
+}
+/**
+ * FeatureGate — conditionally renders content based on a feature flag.
+ */
+export declare function FeatureGate({ flag, children, fallback, loading, invert, defaultValue, }: FeatureGateProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FeatureGate.d.ts.map

package/dist/shared/feature-flags/FeatureGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureGate.d.ts","sourceRoot":"","sources":["../../../src/shared/feature-flags/FeatureGate.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,QAAQ,EAAE,SAAS,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,gDAAgD;IAChD,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAI,EACJ,QAAQ,EACR,QAAe,EACf,OAAc,EACd,MAAc,EACd,YAAmB,GACpB,EAAE,gBAAgB,2CAiBlB"}

package/dist/shared/feature-flags/FeatureGate.js

@@ -0,0 +1,10 @@
+import { useFeatureFlags as e } from "./FeatureFlagProvider.js";
+import { useFeatureFlag as t } from "./useFeatureFlag.js";
+import { Fragment as n, jsx as r } from "react/jsx-runtime";
+//#region src/shared/feature-flags/FeatureGate.tsx
+function i({ flag: i, children: a, fallback: o = null, loading: s = null, invert: c = !1, defaultValue: l = !0 }) {
+	let { isLoading: u } = e(), d = t(i, l);
+	return u && s ? /* @__PURE__ */ r(n, { children: s }) : (c ? !d : d) ? /* @__PURE__ */ r(n, { children: a }) : /* @__PURE__ */ r(n, { children: o });
+}
+//#endregion
+export { i as FeatureGate };

package/dist/shared/feature-flags/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @burdenoff/fe-libs/shared/feature-flags
+ *
+ * Enhanced feature flag module for Burdenoff products.
+ *
+ * Provides a React context provider that evaluates feature flags against
+ * the global-tenant-svc backend, with workspace-aware re-fetching,
+ * polling, and default-allow semantics.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   FeatureFlagProvider,
+ *   useFeatureFlags,
+ *   useFeatureFlag,
+ *   FeatureGate,
+ * } from '@burdenoff/fe-libs/shared/feature-flags';
+ *
+ * // In shell
+ * <FeatureFlagProvider workspaceId={workspaceId}>
+ *   <App />
+ * </FeatureFlagProvider>
+ *
+ * // In components
+ * const isEnabled = useFeatureFlag('new-dashboard');
+ * // or
+ * <FeatureGate flag="new-dashboard" fallback={<LegacyDashboard />}>
+ *   <NewDashboard />
+ * </FeatureGate>
+ * ```
+ */
+export { FeatureFlagProvider, useFeatureFlags } from './FeatureFlagProvider';
+export type { FeatureFlagProviderProps } from './FeatureFlagProvider';
+export { useFeatureFlag, useFeatureFlagValue, useFeatureFlagDetails, } from './useFeatureFlag';
+export { FeatureGate } from './FeatureGate';
+export type { FeatureGateProps } from './FeatureGate';
+export type { FlagValue, FlagType, FlagStatus, FlagEvaluation, BulkEvaluationResponse, FeatureFlagProviderConfig, FeatureFlagContextValue, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/feature-flags/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/feature-flags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7E,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,YAAY,EACV,SAAS,EACT,QAAQ,EACR,UAAU,EACV,cAAc,EACd,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,SAAS,CAAC"}