@interfere/react 9.0.2 → 10.0.0

package/README.md

@@ -2,16 +2,16 @@
   <a href="https://interfere.com">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-dark.png">
-      <img src="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-light.png" height="64">
+      <img src="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-light.png" height="64" alt="Interfere">
     </picture>
   </a>
   <h1 align="center">@interfere/react</h1>
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@interfere/react"><img src="https://img.shields.io/npm/v/@interfere/react.svg" /></a>
-  <a href="https://github.com/interfere-inc/interfere/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@interfere/react.svg" /></a>
-  <a href="https://www.npmjs.com/package/@interfere/react"><img src="https://img.shields.io/npm/dm/@interfere/react.svg" /></a>
+  <a href="https://www.npmjs.com/package/@interfere/react"><img src="https://img.shields.io/npm/v/@interfere/react.svg" alt="npm version" /></a>
+  <a href="https://github.com/interfere-inc/interfere/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@interfere/react.svg" alt="License" /></a>
+  <a href="https://www.npmjs.com/package/@interfere/react"><img src="https://img.shields.io/npm/dm/@interfere/react.svg" alt="npm downloads" /></a>
 </p>
 
 <p align="center">

package/dist/api.d.mts

@@ -0,0 +1,25 @@
+import { Span, SpanOptions } from "@opentelemetry/api";
+
+//#region src/api.d.ts
+/**
+ * Wraps `fn` in an OTel span. The span becomes the active context for the
+ * duration of the call (sync) or the awaited promise (async). Errors thrown
+ * by `fn` are recorded on the span before re-throwing — caller still owns
+ * the error.
+ *
+ * Works pre-init: `trace.getTracer()` returns a no-op tracer that still
+ * runs `fn` and propagates its return value, so call sites don't need
+ * defensive checks.
+ */
+declare function span<T>(name: string, fn: (span: Span) => T, options?: SpanOptions): T;
+/**
+ * Captures an error. Records on the active OTel span (when present) AND on
+ * the legacy envelope path. Accepts any thrown value; non-Error inputs that
+ * carry structure (objects without a recoverable nested Error) are preserved
+ * via `toException` so the original shape survives to the wire.
+ *
+ * Safe to call before init — drops silently if no kernel is registered.
+ */
+declare function capture(error: unknown): void;
+//#endregion
+export { capture, span };

package/dist/api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../src/api.ts"],"mappings":";;;;;AAuCA;;;;;;;;iBAAgB,IAAA,GAAA,CACd,IAAA,UACA,EAAA,GAAK,IAAA,EAAM,IAAA,KAAS,CAAA,EACpB,OAAA,GAAU,WAAA,GACT,CAAA;;;;;;;;;iBAuCa,OAAA,CAAQ,KAAA"}

package/dist/api.mjs

@@ -0,0 +1,68 @@
+import { activeKernel } from "./internal/kernel-registry.mjs";
+import { MECHANISM_TYPE, toError, toException } from "@interfere/types/sdk/errors";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+//#region src/api.ts
+const TRACER_NAME = "@interfere/react";
+function tracer() {
+	return trace.getTracer(TRACER_NAME);
+}
+function isPromise(value) {
+	return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+/**
+* Wraps `fn` in an OTel span. The span becomes the active context for the
+* duration of the call (sync) or the awaited promise (async). Errors thrown
+* by `fn` are recorded on the span before re-throwing — caller still owns
+* the error.
+*
+* Works pre-init: `trace.getTracer()` returns a no-op tracer that still
+* runs `fn` and propagates its return value, so call sites don't need
+* defensive checks.
+*/
+function span(name, fn, options) {
+	return tracer().startActiveSpan(name, options ?? {}, (s) => {
+		try {
+			const result = fn(s);
+			if (isPromise(result)) return result.then((value) => {
+				s.end();
+				return value;
+			}, (err) => {
+				const e = toError(err);
+				s.recordException(e);
+				s.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: e.message
+				});
+				s.end();
+				throw err;
+			});
+			s.end();
+			return result;
+		} catch (err) {
+			const e = toError(err);
+			s.recordException(e);
+			s.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: e.message
+			});
+			s.end();
+			throw err;
+		}
+	});
+}
+/**
+* Captures an error. Records on the active OTel span (when present) AND on
+* the legacy envelope path. Accepts any thrown value; non-Error inputs that
+* carry structure (objects without a recoverable nested Error) are preserved
+* via `toException` so the original shape survives to the wire.
+*
+* Safe to call before init — drops silently if no kernel is registered.
+*/
+function capture(error) {
+	activeKernel()?.recordException(toException(error), { mechanism: {
+		type: MECHANISM_TYPE.manual.capture,
+		handled: true
+	} });
+}
+//#endregion
+export { capture, span };

package/dist/api.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.mjs","names":[],"sources":["../src/api.ts"],"sourcesContent":["import {\n  MECHANISM_TYPE,\n  toError,\n  toException,\n} from \"@interfere/types/sdk/errors\";\n\nimport {\n  type Span,\n  type SpanOptions,\n  SpanStatusCode,\n  trace,\n} from \"@opentelemetry/api\";\n\nimport { activeKernel } from \"./internal/kernel-registry.js\";\n\nconst TRACER_NAME = \"@interfere/react\";\n\nfunction tracer() {\n  return trace.getTracer(TRACER_NAME);\n}\n\nfunction isPromise<T>(value: unknown): value is Promise<T> {\n  return (\n    !!value &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    typeof (value as { then?: unknown }).then === \"function\"\n  );\n}\n\n/**\n * Wraps `fn` in an OTel span. The span becomes the active context for the\n * duration of the call (sync) or the awaited promise (async). Errors thrown\n * by `fn` are recorded on the span before re-throwing — caller still owns\n * the error.\n *\n * Works pre-init: `trace.getTracer()` returns a no-op tracer that still\n * runs `fn` and propagates its return value, so call sites don't need\n * defensive checks.\n */\nexport function span<T>(\n  name: string,\n  fn: (span: Span) => T,\n  options?: SpanOptions\n): T {\n  return tracer().startActiveSpan(name, options ?? {}, (s): T => {\n    try {\n      const result = fn(s);\n      if (isPromise<T>(result)) {\n        return result.then(\n          (value) => {\n            s.end();\n            return value;\n          },\n          (err: unknown) => {\n            const e = toError(err);\n            s.recordException(e);\n            s.setStatus({ code: SpanStatusCode.ERROR, message: e.message });\n            s.end();\n            throw err;\n          }\n        ) as T;\n      }\n      s.end();\n      return result;\n    } catch (err) {\n      const e = toError(err);\n      s.recordException(e);\n      s.setStatus({ code: SpanStatusCode.ERROR, message: e.message });\n      s.end();\n      throw err;\n    }\n  });\n}\n\n/**\n * Captures an error. Records on the active OTel span (when present) AND on\n * the legacy envelope path. Accepts any thrown value; non-Error inputs that\n * carry structure (objects without a recoverable nested Error) are preserved\n * via `toException` so the original shape survives to the wire.\n *\n * Safe to call before init — drops silently if no kernel is registered.\n */\nexport function capture(error: unknown): void {\n  activeKernel()?.recordException(toException(error), {\n    mechanism: { type: MECHANISM_TYPE.manual.capture, handled: true },\n  });\n}\n"],"mappings":";;;;AAeA,MAAM,cAAc;AAEpB,SAAS,SAAS;CAChB,OAAO,MAAM,UAAU,YAAY;;AAGrC,SAAS,UAAa,OAAqC;CACzD,OACE,CAAC,CAAC,UACD,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAA6B,SAAS;;;;;;;;;;;;AAclD,SAAgB,KACd,MACA,IACA,SACG;CACH,OAAO,QAAQ,CAAC,gBAAgB,MAAM,WAAW,EAAE,GAAG,MAAS;EAC7D,IAAI;GACF,MAAM,SAAS,GAAG,EAAE;GACpB,IAAI,UAAa,OAAO,EACtB,OAAO,OAAO,MACX,UAAU;IACT,EAAE,KAAK;IACP,OAAO;OAER,QAAiB;IAChB,MAAM,IAAI,QAAQ,IAAI;IACtB,EAAE,gBAAgB,EAAE;IACpB,EAAE,UAAU;KAAE,MAAM,eAAe;KAAO,SAAS,EAAE;KAAS,CAAC;IAC/D,EAAE,KAAK;IACP,MAAM;KAET;GAEH,EAAE,KAAK;GACP,OAAO;WACA,KAAK;GACZ,MAAM,IAAI,QAAQ,IAAI;GACtB,EAAE,gBAAgB,EAAE;GACpB,EAAE,UAAU;IAAE,MAAM,eAAe;IAAO,SAAS,EAAE;IAAS,CAAC;GAC/D,EAAE,KAAK;GACP,MAAM;;GAER;;;;;;;;;;AAWJ,SAAgB,QAAQ,OAAsB;CAC5C,cAAc,EAAE,gBAAgB,YAAY,MAAM,EAAE,EAClD,WAAW;EAAE,MAAM,eAAe,OAAO;EAAS,SAAS;EAAM,EAClE,CAAC"}

package/dist/error-boundary.d.mts

@@ -1,4 +1,6 @@
-import { Component, ErrorInfo, ReactNode } from "react";
+import { InterfereContext, InterfereContextValue } from "./internal/react-context.mjs";
+import * as _$react from "react";
+import { Component, ContextType, ErrorInfo, ReactNode } from "react";
 
 //#region src/error-boundary.d.ts
 interface ErrorBoundaryProps {
@@ -11,15 +13,20 @@ interface ErrorBoundaryState {
 }
 /**
  * Catches render-phase React errors, reports them to the SDK, and renders a
- * fallback. Requires the SDK to be bootstrapped via `init()` before React
- * renders so `capture` has an active runtime.
+ * fallback. Reads the kernel from `InterfereContext`; mounting outside the
+ * provider is supported — capture is silently skipped, fallback + `onError`
+ * still fire.
  *
  * Class component required — React has no hook-based error boundary API.
  */
 declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  static contextType: _$react.Context<InterfereContextValue | null>;
+  context: ContextType<typeof InterfereContext>;
   state: ErrorBoundaryState;
   static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-  componentDidCatch(error: Error, info: ErrorInfo): void;
+  componentDidCatch(error: Error & {
+    digest?: string;
+  }, info: ErrorInfo): void;
   private readonly reset;
   render(): ReactNode;
 }

package/dist/error-boundary.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"error-boundary.d.mts","names":[],"sources":["../src/error-boundary.tsx"],"mappings":";;;UAQiB,kBAAA;EACf,QAAA,EAAU,SAAA;EACV,QAAA,GAAW,SAAA,KAAc,KAAA,EAAO,KAAA,EAAO,KAAA,iBAAsB,SAAA;EAC7D,OAAA,IAAW,KAAA,EAAO,KAAA,EAAO,IAAA,EAAM,SAAA;AAAA;AAAA,UAGvB,kBAAA;EACR,KAAA,EAAO,KAAA;AAAA;;;;;;;;cAUI,aAAA,SAAsB,SAAA,CACjC,kBAAA,EACA,kBAAA;EAES,KAAA,EAAO,kBAAA;EAAA,OAET,wBAAA,CAAyB,KAAA,EAAO,KAAA,GAAQ,kBAAA;EAItC,iBAAA,CAAkB,KAAA,EAAO,KAAA,EAAO,IAAA,EAAM,SAAA;EAAA,iBAS9B,KAAA;EAIR,MAAA,CAAA,GAAM,SAAA;AAAA"}
+{"version":3,"file":"error-boundary.d.mts","names":[],"sources":["../src/error-boundary.tsx"],"mappings":";;;;;UAciB,kBAAA;EACf,QAAA,EAAU,SAAA;EACV,QAAA,GAAW,SAAA,KAAc,KAAA,EAAO,KAAA,EAAO,KAAA,iBAAsB,SAAA;EAC7D,OAAA,IAAW,KAAA,EAAO,KAAA,EAAO,IAAA,EAAM,SAAA;AAAA;AAAA,UAGvB,kBAAA;EACR,KAAA,EAAO,KAAA;AAAA;;;;;;;;;cAWI,aAAA,SAAsB,SAAA,CACjC,kBAAA,EACA,kBAAA;EAAA,OAEgB,WAAA,EAAW,OAAA,CAAA,OAAA,CAFT,qBAAA;EAGV,OAAA,EAAS,WAAA,QAAmB,gBAAA;EAE3B,KAAA,EAAO,kBAAA;EAAA,OAET,wBAAA,CAAyB,KAAA,EAAO,KAAA,GAAQ,kBAAA;EAItC,iBAAA,CACP,KAAA,EAAO,KAAA;IAAU,MAAA;EAAA,GACjB,IAAA,EAAM,SAAA;EAAA,iBAeS,KAAA;EAIR,MAAA,CAAA,GAAM,SAAA;AAAA"}

package/dist/error-boundary.mjs

@@ -1,22 +1,25 @@
 "use client";
 import { captureReactError } from "./internal/capture.mjs";
+import { InterfereContext } from "./internal/react-context.mjs";
 import { MECHANISM_TYPE } from "@interfere/types/sdk/errors";
 import { Component } from "react";
 //#region src/error-boundary.tsx
 /**
 * Catches render-phase React errors, reports them to the SDK, and renders a
-* fallback. Requires the SDK to be bootstrapped via `init()` before React
-* renders so `capture` has an active runtime.
+* fallback. Reads the kernel from `InterfereContext`; mounting outside the
+* provider is supported — capture is silently skipped, fallback + `onError`
+* still fire.
 *
 * Class component required — React has no hook-based error boundary API.
 */
 var ErrorBoundary = class extends Component {
+	static contextType = InterfereContext;
 	state = { error: null };
 	static getDerivedStateFromError(error) {
 		return { error };
 	}
 	componentDidCatch(error, info) {
-		captureReactError(error, info.componentStack, {
+		captureReactError(this.context?.kernel ?? null, error, info.componentStack, {
 			type: MECHANISM_TYPE.react.errorBoundary,
 			handled: true
 		});

package/dist/error-boundary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"error-boundary.mjs","names":[],"sources":["../src/error-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport { MECHANISM_TYPE } from \"@interfere/types/sdk/errors\";\n\nimport { Component, type ErrorInfo, type ReactNode } from \"react\";\n\nimport { captureReactError } from \"./internal/capture.js\";\n\nexport interface ErrorBoundaryProps {\n  children: ReactNode;\n  fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);\n  onError?: (error: Error, info: ErrorInfo) => void;\n}\n\ninterface ErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Catches render-phase React errors, reports them to the SDK, and renders a\n * fallback. Requires the SDK to be bootstrapped via `init()` before React\n * renders so `capture` has an active runtime.\n *\n * Class component required — React has no hook-based error boundary API.\n */\nexport class ErrorBoundary extends Component<\n  ErrorBoundaryProps,\n  ErrorBoundaryState\n> {\n  override state: ErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    return { error };\n  }\n\n  override componentDidCatch(error: Error, info: ErrorInfo) {\n    captureReactError(error, info.componentStack, {\n      type: MECHANISM_TYPE.react.errorBoundary,\n      handled: true,\n    });\n\n    this.props.onError?.(error, info);\n  }\n\n  private readonly reset = () => {\n    this.setState({ error: null });\n  };\n\n  override render() {\n    const { error } = this.state;\n\n    if (error) {\n      const { fallback } = this.props;\n      if (typeof fallback === \"function\") {\n        return fallback(error, this.reset);\n      }\n      return fallback ?? null;\n    }\n\n    return this.props.children;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAyBA,IAAa,gBAAb,cAAmC,UAGjC;CACA,QAAqC,EAAE,OAAO,MAAM;CAEpD,OAAO,yBAAyB,OAAkC;AAChE,SAAO,EAAE,OAAO;;CAGlB,kBAA2B,OAAc,MAAiB;AACxD,oBAAkB,OAAO,KAAK,gBAAgB;GAC5C,MAAM,eAAe,MAAM;GAC3B,SAAS;GACV,CAAC;AAEF,OAAK,MAAM,UAAU,OAAO,KAAK;;CAGnC,cAA+B;AAC7B,OAAK,SAAS,EAAE,OAAO,MAAM,CAAC;;CAGhC,SAAkB;EAChB,MAAM,EAAE,UAAU,KAAK;AAEvB,MAAI,OAAO;GACT,MAAM,EAAE,aAAa,KAAK;AAC1B,OAAI,OAAO,aAAa,WACtB,QAAO,SAAS,OAAO,KAAK,MAAM;AAEpC,UAAO,YAAY;;AAGrB,SAAO,KAAK,MAAM"}
+{"version":3,"file":"error-boundary.mjs","names":[],"sources":["../src/error-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport { MECHANISM_TYPE } from \"@interfere/types/sdk/errors\";\n\nimport {\n  Component,\n  type ContextType,\n  type ErrorInfo,\n  type ReactNode,\n} from \"react\";\n\nimport { captureReactError } from \"./internal/capture.js\";\nimport { InterfereContext } from \"./internal/react-context.js\";\n\nexport interface ErrorBoundaryProps {\n  children: ReactNode;\n  fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);\n  onError?: (error: Error, info: ErrorInfo) => void;\n}\n\ninterface ErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Catches render-phase React errors, reports them to the SDK, and renders a\n * fallback. Reads the kernel from `InterfereContext`; mounting outside the\n * provider is supported — capture is silently skipped, fallback + `onError`\n * still fire.\n *\n * Class component required — React has no hook-based error boundary API.\n */\nexport class ErrorBoundary extends Component<\n  ErrorBoundaryProps,\n  ErrorBoundaryState\n> {\n  static override contextType = InterfereContext;\n  declare context: ContextType<typeof InterfereContext>;\n\n  override state: ErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    return { error };\n  }\n\n  override componentDidCatch(\n    error: Error & { digest?: string },\n    info: ErrorInfo\n  ) {\n    captureReactError(\n      this.context?.kernel ?? null,\n      error,\n      info.componentStack,\n      {\n        type: MECHANISM_TYPE.react.errorBoundary,\n        handled: true,\n      }\n    );\n\n    this.props.onError?.(error, info);\n  }\n\n  private readonly reset = () => {\n    this.setState({ error: null });\n  };\n\n  override render() {\n    const { error } = this.state;\n\n    if (error) {\n      const { fallback } = this.props;\n      if (typeof fallback === \"function\") {\n        return fallback(error, this.reset);\n      }\n      return fallback ?? null;\n    }\n\n    return this.props.children;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgCA,IAAa,gBAAb,cAAmC,UAGjC;CACA,OAAgB,cAAc;CAG9B,QAAqC,EAAE,OAAO,MAAM;CAEpD,OAAO,yBAAyB,OAAkC;EAChE,OAAO,EAAE,OAAO;;CAGlB,kBACE,OACA,MACA;EACA,kBACE,KAAK,SAAS,UAAU,MACxB,OACA,KAAK,gBACL;GACE,MAAM,eAAe,MAAM;GAC3B,SAAS;GACV,CACF;EAED,KAAK,MAAM,UAAU,OAAO,KAAK;;CAGnC,cAA+B;EAC7B,KAAK,SAAS,EAAE,OAAO,MAAM,CAAC;;CAGhC,SAAkB;EAChB,MAAM,EAAE,UAAU,KAAK;EAEvB,IAAI,OAAO;GACT,MAAM,EAAE,aAAa,KAAK;GAC1B,IAAI,OAAO,aAAa,YACtB,OAAO,SAAS,OAAO,KAAK,MAAM;GAEpC,OAAO,YAAY;;EAGrB,OAAO,KAAK,MAAM"}

package/dist/internal/browser-context.d.mts

@@ -0,0 +1,6 @@
+import { BrowserContext } from "@interfere/types/sdk/plugins/context/browser";
+
+//#region src/internal/browser-context.d.ts
+declare function collectContext(): Promise<BrowserContext>;
+//#endregion
+export { collectContext };

package/dist/internal/browser-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-context.d.mts","names":[],"sources":["../../src/internal/browser-context.ts"],"mappings":";;;iBA0GsB,cAAA,CAAA,GAAkB,OAAA,CAAQ,cAAA"}

package/dist/internal/browser-context.mjs

@@ -0,0 +1,59 @@
+import { UAParser } from "@ua-parser-js/pro-enterprise";
+import { InApps } from "@ua-parser-js/pro-enterprise/extensions";
+import { isFrozenUA } from "@ua-parser-js/pro-enterprise/helpers";
+//#region src/internal/browser-context.ts
+const NOT_A_BRAND_REGEX = /not.a.brand/i;
+const HIGH_ENTROPY_HINTS = [
+	"bitness",
+	"platformVersion",
+	"fullVersionList"
+];
+async function getDeviceMetadata() {
+	if (typeof navigator === "undefined") return null;
+	const uaData = navigator.userAgentData;
+	const [parsed, hints] = await Promise.all([UAParser(navigator.userAgent, InApps).withClientHints(), uaData?.getHighEntropyValues ? uaData.getHighEntropyValues(HIGH_ENTROPY_HINTS).catch(() => ({})) : Promise.resolve({})]);
+	if (!parsed) return null;
+	const fullVersion = hints.fullVersionList?.find((b) => !NOT_A_BRAND_REGEX.test(b.brand))?.version;
+	return {
+		...parsed,
+		browser: {
+			...parsed.browser,
+			...fullVersion ? { fullVersion } : {}
+		},
+		cpu: {
+			...parsed.cpu,
+			...hints.bitness ? { bitness: hints.bitness } : {}
+		},
+		os: {
+			...parsed.os,
+			...hints.platformVersion ? { versionFull: hints.platformVersion } : {}
+		},
+		frozenUa: isFrozenUA(navigator.userAgent)
+	};
+}
+function getBrowserMetadata() {
+	if ([
+		typeof navigator,
+		typeof screen,
+		typeof globalThis
+	].some((x) => x === "undefined")) return null;
+	const { language } = navigator;
+	return {
+		language,
+		timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+		display: { screen: {
+			height: screen.availHeight,
+			width: screen.availWidth,
+			orientation: screen.orientation?.type
+		} }
+	};
+}
+async function collectContext() {
+	return {
+		runtime: "browser",
+		browser: getBrowserMetadata(),
+		device: await getDeviceMetadata()
+	};
+}
+//#endregion
+export { collectContext };

package/dist/internal/browser-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-context.mjs","names":[],"sources":["../../src/internal/browser-context.ts"],"sourcesContent":["import type {\n  BrowserContext,\n  BrowserMetadata,\n  DeviceMetadata,\n} from \"@interfere/types/sdk/plugins/context/browser\";\n\nimport { UAParser } from \"@ua-parser-js/pro-enterprise\";\nimport { InApps } from \"@ua-parser-js/pro-enterprise/extensions\";\nimport { isFrozenUA } from \"@ua-parser-js/pro-enterprise/helpers\";\n\ninterface NavigatorUABrand {\n  brand: string;\n  version: string;\n}\n\ninterface NavigatorUAData {\n  brands?: NavigatorUABrand[];\n  getHighEntropyValues?: (hints: string[]) => Promise<HighEntropyValues>;\n}\n\ninterface HighEntropyValues {\n  bitness?: string;\n  fullVersionList?: NavigatorUABrand[];\n  platformVersion?: string;\n}\n\nconst NOT_A_BRAND_REGEX = /not.a.brand/i;\nconst HIGH_ENTROPY_HINTS = [\"bitness\", \"platformVersion\", \"fullVersionList\"];\n\nasync function getDeviceMetadata(): Promise<DeviceMetadata | null> {\n  if (typeof navigator === \"undefined\") {\n    return null;\n  }\n\n  const uaData = (navigator as Navigator & { userAgentData?: NavigatorUAData })\n    .userAgentData;\n\n  // `withClientHints()` resolves with UA-only data on non-Chromium and never\n  // rejects. We separately request the raw high-entropy values so we can\n  // surface `bitness`, the unrounded `platformVersion`, and the full\n  // browser version — fields the parser folds into existing slots and\n  // therefore loses precision on. `getHighEntropyValues` can reject with\n  // `NotAllowedError` (Permissions Policy / Privacy Budget); swallow it.\n  // The `InApps` extension is merged into the default regex map (see\n  // `extend(defaultRegexes, extensions)` in ua-parser-js), so we still get\n  // normal browser/OS detection plus tagging for in-app browsers (Slack,\n  // Teams, Discord, VS Code, etc.) — those land as `browser.type: \"inapp\"`.\n  const [parsed, hints] = await Promise.all([\n    UAParser(navigator.userAgent, InApps).withClientHints(),\n    uaData?.getHighEntropyValues\n      ? uaData\n          .getHighEntropyValues(HIGH_ENTROPY_HINTS)\n          .catch((): HighEntropyValues => ({}))\n      : Promise.resolve<HighEntropyValues>({}),\n  ]);\n\n  if (!parsed) {\n    return null;\n  }\n\n  const fullVersion = hints.fullVersionList?.find(\n    (b) => !NOT_A_BRAND_REGEX.test(b.brand)\n  )?.version;\n\n  return {\n    ...parsed,\n    browser: {\n      ...parsed.browser,\n      ...(fullVersion ? { fullVersion } : {}),\n    },\n    cpu: {\n      ...parsed.cpu,\n      ...(hints.bitness ? { bitness: hints.bitness } : {}),\n    },\n    os: {\n      ...parsed.os,\n      ...(hints.platformVersion ? { versionFull: hints.platformVersion } : {}),\n    },\n    frozenUa: isFrozenUA(navigator.userAgent),\n  };\n}\n\nfunction getBrowserMetadata(): BrowserMetadata | null {\n  if (\n    [typeof navigator, typeof screen, typeof globalThis].some(\n      (x) => x === \"undefined\"\n    )\n  ) {\n    return null;\n  }\n\n  const { language } = navigator;\n\n  return {\n    language,\n    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n    display: {\n      screen: {\n        height: screen.availHeight,\n        width: screen.availWidth,\n        orientation: screen.orientation?.type,\n      },\n    },\n  };\n}\n\nexport async function collectContext(): Promise<BrowserContext> {\n  return {\n    runtime: \"browser\",\n    browser: getBrowserMetadata(),\n    device: await getDeviceMetadata(),\n  };\n}\n"],"mappings":";;;;AA0BA,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;CAAC;CAAW;CAAmB;CAAkB;AAE5E,eAAe,oBAAoD;CACjE,IAAI,OAAO,cAAc,aACvB,OAAO;CAGT,MAAM,SAAU,UACb;CAYH,MAAM,CAAC,QAAQ,SAAS,MAAM,QAAQ,IAAI,CACxC,SAAS,UAAU,WAAW,OAAO,CAAC,iBAAiB,EACvD,QAAQ,uBACJ,OACG,qBAAqB,mBAAmB,CACxC,aAAgC,EAAE,EAAE,GACvC,QAAQ,QAA2B,EAAE,CAAC,CAC3C,CAAC;CAEF,IAAI,CAAC,QACH,OAAO;CAGT,MAAM,cAAc,MAAM,iBAAiB,MACxC,MAAM,CAAC,kBAAkB,KAAK,EAAE,MAAM,CACxC,EAAE;CAEH,OAAO;EACL,GAAG;EACH,SAAS;GACP,GAAG,OAAO;GACV,GAAI,cAAc,EAAE,aAAa,GAAG,EAAE;GACvC;EACD,KAAK;GACH,GAAG,OAAO;GACV,GAAI,MAAM,UAAU,EAAE,SAAS,MAAM,SAAS,GAAG,EAAE;GACpD;EACD,IAAI;GACF,GAAG,OAAO;GACV,GAAI,MAAM,kBAAkB,EAAE,aAAa,MAAM,iBAAiB,GAAG,EAAE;GACxE;EACD,UAAU,WAAW,UAAU,UAAU;EAC1C;;AAGH,SAAS,qBAA6C;CACpD,IACE;EAAC,OAAO;EAAW,OAAO;EAAQ,OAAO;EAAW,CAAC,MAClD,MAAM,MAAM,YACd,EAED,OAAO;CAGT,MAAM,EAAE,aAAa;CAErB,OAAO;EACL;EACA,UAAU,KAAK,gBAAgB,CAAC,iBAAiB,CAAC;EAClD,SAAS,EACP,QAAQ;GACN,QAAQ,OAAO;GACf,OAAO,OAAO;GACd,aAAa,OAAO,aAAa;GAClC,EACF;EACF;;AAGH,eAAsB,iBAA0C;CAC9D,OAAO;EACL,SAAS;EACT,SAAS,oBAAoB;EAC7B,QAAQ,MAAM,mBAAmB;EAClC"}

package/dist/internal/capture-boundary.d.mts

@@ -1,4 +1,6 @@
-import { Component, ReactNode } from "react";
+import { InterfereContext, InterfereContextValue } from "./react-context.mjs";
+import * as _$react from "react";
+import { Component, ContextType, ReactNode } from "react";
 
 //#region src/internal/capture-boundary.d.ts
 interface CaptureBoundaryProps {
@@ -31,6 +33,8 @@ interface CaptureBoundaryState {
  * captured the error but did not render a fallback — propagation continues.
  */
 declare class CaptureBoundary extends Component<CaptureBoundaryProps, CaptureBoundaryState> {
+  static contextType: _$react.Context<InterfereContextValue | null>;
+  context: ContextType<typeof InterfereContext>;
   state: CaptureBoundaryState;
   static getDerivedStateFromError(error: Error): CaptureBoundaryState;
   render(): ReactNode;

package/dist/internal/capture-boundary.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"capture-boundary.d.mts","names":[],"sources":["../../src/internal/capture-boundary.tsx"],"mappings":";;;UAQU,oBAAA;EACR,QAAA,EAAU,SAAA;AAAA;AAAA,UAGF,oBAAA;EACR,KAAA,EAAO,KAAA;AAAA;;AAJY;;;;;AA8BrB;;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,SAAA,CACnC,oBAAA,EACA,oBAAA;EAES,KAAA,EAAO,oBAAA;EAAA,OAET,wBAAA,CAAyB,KAAA,EAAO,KAAA,GAAQ,oBAAA;EAQtC,MAAA,CAAA,GAAU,SAAA;AAAA"}
+{"version":3,"file":"capture-boundary.d.mts","names":[],"sources":["../../src/internal/capture-boundary.tsx"],"mappings":";;;;;UASU,oBAAA;EACR,QAAA,EAAU,SAAA;AAAA;AAAA,UAGF,oBAAA;EACR,KAAA,EAAO,KAAA;AAAA;;;AAJY;;;;;AA8BrB;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,SAAA,CACnC,oBAAA,EACA,oBAAA;EAAA,OAEgB,WAAA,EAAW,OAAA,CAAA,OAAA,CAFP,qBAAA;EAGZ,OAAA,EAAS,WAAA,QAAmB,gBAAA;EAE3B,KAAA,EAAO,oBAAA;EAAA,OAET,wBAAA,CAAyB,KAAA,EAAO,KAAA,GAAQ,oBAAA;EAItC,MAAA,CAAA,GAAU,SAAA;AAAA"}

package/dist/internal/capture-boundary.mjs

@@ -1,5 +1,6 @@
 "use client";
 import { captureReactError } from "./capture.mjs";
+import { InterfereContext } from "./react-context.mjs";
 import { MECHANISM_TYPE } from "@interfere/types/sdk/errors";
 import { Component } from "react";
 //#region src/internal/capture-boundary.tsx
@@ -27,16 +28,19 @@ import { Component } from "react";
 * captured the error but did not render a fallback — propagation continues.
 */
 var CaptureBoundary = class extends Component {
+	static contextType = InterfereContext;
 	state = { error: null };
 	static getDerivedStateFromError(error) {
-		captureReactError(error, null, {
-			type: MECHANISM_TYPE.react.captureBoundary,
-			handled: false
-		});
 		return { error };
 	}
 	render() {
-		if (this.state.error) throw this.state.error;
+		if (this.state.error) {
+			captureReactError(this.context?.kernel ?? null, this.state.error, null, {
+				type: MECHANISM_TYPE.react.captureBoundary,
+				handled: false
+			});
+			throw this.state.error;
+		}
 		return this.props.children;
 	}
 };

package/dist/internal/capture-boundary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"capture-boundary.mjs","names":[],"sources":["../../src/internal/capture-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport { MECHANISM_TYPE } from \"@interfere/types/sdk/errors\";\n\nimport { Component, type ReactNode } from \"react\";\n\nimport { captureReactError } from \"./capture.js\";\n\ninterface CaptureBoundaryProps {\n  children: ReactNode;\n}\n\ninterface CaptureBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Internal boundary used by `<InterfereProvider>` to capture render-phase\n * React errors without changing the app's UX.\n *\n * Unlike the public `ErrorBoundary`, this boundary always re-throws the\n * captured error in its `render()` so upstream boundaries — the customer's\n * own `ErrorBoundary`, Next.js's `error.tsx` / `global-error.tsx`, or React's\n * default unmount — keep control of what the user sees. The net effect:\n * zero visual change, full capture coverage for any render-phase error in\n * the subtree.\n *\n * Capture happens inside `getDerivedStateFromError` rather than\n * `componentDidCatch` because `componentDidCatch` does not fire on a boundary\n * that re-throws in render — React considers such a boundary to have failed\n * and skips its commit-phase lifecycle. The trade-off: we don't get\n * `errorInfo.componentStack` in this capture. Callers who want the component\n * tree should use the public `ErrorBoundary` (which renders a fallback and\n * therefore receives `componentDidCatch`), or pass\n * {@link reactErrorHandler} to `createRoot()`.\n *\n * `mechanism.handled` is `false` because from Interfere's perspective we\n * captured the error but did not render a fallback — propagation continues.\n */\nexport class CaptureBoundary extends Component<\n  CaptureBoundaryProps,\n  CaptureBoundaryState\n> {\n  override state: CaptureBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): CaptureBoundaryState {\n    captureReactError(error, null, {\n      type: MECHANISM_TYPE.react.captureBoundary,\n      handled: false,\n    });\n    return { error };\n  }\n\n  override render(): ReactNode {\n    if (this.state.error) {\n      throw this.state.error;\n    }\n    return this.props.children;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,kBAAb,cAAqC,UAGnC;CACA,QAAuC,EAAE,OAAO,MAAM;CAEtD,OAAO,yBAAyB,OAAoC;AAClE,oBAAkB,OAAO,MAAM;GAC7B,MAAM,eAAe,MAAM;GAC3B,SAAS;GACV,CAAC;AACF,SAAO,EAAE,OAAO;;CAGlB,SAA6B;AAC3B,MAAI,KAAK,MAAM,MACb,OAAM,KAAK,MAAM;AAEnB,SAAO,KAAK,MAAM"}
+{"version":3,"file":"capture-boundary.mjs","names":[],"sources":["../../src/internal/capture-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport { MECHANISM_TYPE } from \"@interfere/types/sdk/errors\";\n\nimport { Component, type ContextType, type ReactNode } from \"react\";\n\nimport { captureReactError } from \"./capture.js\";\nimport { InterfereContext } from \"./react-context.js\";\n\ninterface CaptureBoundaryProps {\n  children: ReactNode;\n}\n\ninterface CaptureBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Internal boundary used by `<InterfereProvider>` to capture render-phase\n * React errors without changing the app's UX.\n *\n * Unlike the public `ErrorBoundary`, this boundary always re-throws the\n * captured error in its `render()` so upstream boundaries — the customer's\n * own `ErrorBoundary`, Next.js's `error.tsx` / `global-error.tsx`, or React's\n * default unmount — keep control of what the user sees. The net effect:\n * zero visual change, full capture coverage for any render-phase error in\n * the subtree.\n *\n * Capture happens inside `getDerivedStateFromError` rather than\n * `componentDidCatch` because `componentDidCatch` does not fire on a boundary\n * that re-throws in render — React considers such a boundary to have failed\n * and skips its commit-phase lifecycle. The trade-off: we don't get\n * `errorInfo.componentStack` in this capture. Callers who want the component\n * tree should use the public `ErrorBoundary` (which renders a fallback and\n * therefore receives `componentDidCatch`), or pass\n * {@link reactErrorHandler} to `createRoot()`.\n *\n * `mechanism.handled` is `false` because from Interfere's perspective we\n * captured the error but did not render a fallback — propagation continues.\n */\nexport class CaptureBoundary extends Component<\n  CaptureBoundaryProps,\n  CaptureBoundaryState\n> {\n  static override contextType = InterfereContext;\n  declare context: ContextType<typeof InterfereContext>;\n\n  override state: CaptureBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): CaptureBoundaryState {\n    return { error };\n  }\n\n  override render(): ReactNode {\n    if (this.state.error) {\n      // Capture before re-throwing. `componentDidCatch` never fires when\n      // render throws (React treats the boundary itself as failed), so the\n      // capture has to happen here. `captureReactError` dedupes on the\n      // error instance, so the multiple-render case in concurrent React\n      // doesn't cause duplicate captures.\n      captureReactError(this.context?.kernel ?? null, this.state.error, null, {\n        type: MECHANISM_TYPE.react.captureBoundary,\n        handled: false,\n      });\n      throw this.state.error;\n    }\n    return this.props.children;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,kBAAb,cAAqC,UAGnC;CACA,OAAgB,cAAc;CAG9B,QAAuC,EAAE,OAAO,MAAM;CAEtD,OAAO,yBAAyB,OAAoC;EAClE,OAAO,EAAE,OAAO;;CAGlB,SAA6B;EAC3B,IAAI,KAAK,MAAM,OAAO;GAMpB,kBAAkB,KAAK,SAAS,UAAU,MAAM,KAAK,MAAM,OAAO,MAAM;IACtE,MAAM,eAAe,MAAM;IAC3B,SAAS;IACV,CAAC;GACF,MAAM,KAAK,MAAM;;EAEnB,OAAO,KAAK,MAAM"}

package/dist/internal/capture.d.mts

@@ -1,13 +1,24 @@
+import { Kernel } from "./kernel.mjs";
 import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
 
 //#region src/internal/capture.d.ts
 /**
- * Captures a React error through the SDK, attaching the component stack
- * reported by React as additional frames. Dedupes on the Error instance.
+ * Routes a React error through `kernel.recordException()`, attaching the
+ * component stack reported by React as additional frames. Dedup of the
+ * same `Error` instance caught by both the boundary and `window.onerror`
+ * happens inside `recordException`.
  *
- * Swallows errors from `getClient()` so callers can run before the SDK is
- * initialized (e.g. an error boundary catching a pre-init crash).
+ * `error.digest` is React's identifier for an RSC server-side throw that
+ * was sanitised and rebuilt on the client — promote it so enrichment can
+ * fingerprint the redacted client capture into the same problem as the
+ * unredacted server capture.
+ *
+ * Accepts a nullable kernel — error boundaries can mount outside the
+ * `<InterfereProvider>` tree, in which case we silently skip capture and
+ * let the host render its fallback / call its `onError` callback.
  */
-declare function captureReactError(error: Error, componentStack: string | null | undefined, mechanism: ErrorMechanism): void;
+declare function captureReactError(kernel: Kernel | null, error: Error & {
+  digest?: string;
+}, componentStack: string | null | undefined, mechanism: ErrorMechanism): void;
 //#endregion
 export { captureReactError };

package/dist/internal/capture.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"capture.d.mts","names":[],"sources":["../../src/internal/capture.ts"],"mappings":";;;;;AAiBA;;;;;iBAAgB,iBAAA,CACd,KAAA,EAAO,KAAA,EACP,cAAA,6BACA,SAAA,EAAW,cAAA"}
+{"version":3,"file":"capture.d.mts","names":[],"sources":["../../src/internal/capture.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;iBAAgB,iBAAA,CACd,MAAA,EAAQ,MAAA,SACR,KAAA,EAAO,KAAA;EAAU,MAAA;AAAA,GACjB,cAAA,6BACA,SAAA,EAAW,cAAA"}

package/dist/internal/capture.mjs

@@ -1,23 +1,27 @@
-import { seen } from "./errors.mjs";
-import { getClient } from "./client.mjs";
-import { parseReactComponentStack, shouldDropBrowserExtensionNoise, toExceptions } from "@interfere/types/sdk/errors";
+import { parseReactComponentStack } from "@interfere/types/sdk/errors";
 //#region src/internal/capture.ts
 /**
-* Captures a React error through the SDK, attaching the component stack
-* reported by React as additional frames. Dedupes on the Error instance.
+* Routes a React error through `kernel.recordException()`, attaching the
+* component stack reported by React as additional frames. Dedup of the
+* same `Error` instance caught by both the boundary and `window.onerror`
+* happens inside `recordException`.
 *
-* Swallows errors from `getClient()` so callers can run before the SDK is
-* initialized (e.g. an error boundary catching a pre-init crash).
+* `error.digest` is React's identifier for an RSC server-side throw that
+* was sanitised and rebuilt on the client — promote it so enrichment can
+* fingerprint the redacted client capture into the same problem as the
+* unredacted server capture.
+*
+* Accepts a nullable kernel — error boundaries can mount outside the
+* `<InterfereProvider>` tree, in which case we silently skip capture and
+* let the host render its fallback / call its `onError` callback.
 */
-function captureReactError(error, componentStack, mechanism) {
-	if (seen.has(error)) return;
-	seen.add(error);
-	try {
-		const exceptions = toExceptions(error, mechanism);
-		if (componentStack && exceptions[0]) exceptions[0].frames.push(...parseReactComponentStack(componentStack));
-		if (shouldDropBrowserExtensionNoise(exceptions)) return;
-		getClient().capture("error", { exceptions });
-	} catch {}
+function captureReactError(kernel, error, componentStack, mechanism) {
+	if (!kernel) return;
+	kernel.recordException(error, {
+		mechanism,
+		...componentStack ? { appendFrames: parseReactComponentStack(componentStack) } : {},
+		...error.digest ? { errorDigest: error.digest } : {}
+	});
 }
 //#endregion
 export { captureReactError };

package/dist/internal/capture.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"capture.mjs","names":[],"sources":["../../src/internal/capture.ts"],"sourcesContent":["import {\n  parseReactComponentStack,\n  shouldDropBrowserExtensionNoise,\n  toExceptions,\n} from \"@interfere/types/sdk/errors\";\nimport type { ErrorMechanism } from \"@interfere/types/sdk/plugins/payload/errors\";\n\nimport { getClient } from \"./client.js\";\nimport { seen } from \"./errors.js\";\n\n/**\n * Captures a React error through the SDK, attaching the component stack\n * reported by React as additional frames. Dedupes on the Error instance.\n *\n * Swallows errors from `getClient()` so callers can run before the SDK is\n * initialized (e.g. an error boundary catching a pre-init crash).\n */\nexport function captureReactError(\n  error: Error,\n  componentStack: string | null | undefined,\n  mechanism: ErrorMechanism\n): void {\n  if (seen.has(error)) {\n    return;\n  }\n  seen.add(error);\n\n  try {\n    const exceptions = toExceptions(error, mechanism);\n\n    if (componentStack && exceptions[0]) {\n      exceptions[0].frames.push(...parseReactComponentStack(componentStack));\n    }\n\n    if (shouldDropBrowserExtensionNoise(exceptions)) {\n      return;\n    }\n\n    getClient().capture(\"error\", { exceptions });\n  } catch {\n    // SDK not initialized — the caller still gets their fallback / user cb.\n  }\n}\n"],"mappings":";;;;;;;;;;;AAiBA,SAAgB,kBACd,OACA,gBACA,WACM;AACN,KAAI,KAAK,IAAI,MAAM,CACjB;AAEF,MAAK,IAAI,MAAM;AAEf,KAAI;EACF,MAAM,aAAa,aAAa,OAAO,UAAU;AAEjD,MAAI,kBAAkB,WAAW,GAC/B,YAAW,GAAG,OAAO,KAAK,GAAG,yBAAyB,eAAe,CAAC;AAGxE,MAAI,gCAAgC,WAAW,CAC7C;AAGF,aAAW,CAAC,QAAQ,SAAS,EAAE,YAAY,CAAC;SACtC"}
+{"version":3,"file":"capture.mjs","names":[],"sources":["../../src/internal/capture.ts"],"sourcesContent":["import { parseReactComponentStack } from \"@interfere/types/sdk/errors\";\nimport type { ErrorMechanism } from \"@interfere/types/sdk/plugins/payload/errors\";\n\nimport type { Kernel } from \"./kernel.js\";\n\n/**\n * Routes a React error through `kernel.recordException()`, attaching the\n * component stack reported by React as additional frames. Dedup of the\n * same `Error` instance caught by both the boundary and `window.onerror`\n * happens inside `recordException`.\n *\n * `error.digest` is React's identifier for an RSC server-side throw that\n * was sanitised and rebuilt on the client — promote it so enrichment can\n * fingerprint the redacted client capture into the same problem as the\n * unredacted server capture.\n *\n * Accepts a nullable kernel — error boundaries can mount outside the\n * `<InterfereProvider>` tree, in which case we silently skip capture and\n * let the host render its fallback / call its `onError` callback.\n */\nexport function captureReactError(\n  kernel: Kernel | null,\n  error: Error & { digest?: string },\n  componentStack: string | null | undefined,\n  mechanism: ErrorMechanism\n): void {\n  if (!kernel) {\n    return;\n  }\n  kernel.recordException(error, {\n    mechanism,\n    ...(componentStack\n      ? { appendFrames: parseReactComponentStack(componentStack) }\n      : {}),\n    ...(error.digest ? { errorDigest: error.digest } : {}),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,kBACd,QACA,OACA,gBACA,WACM;CACN,IAAI,CAAC,QACH;CAEF,OAAO,gBAAgB,OAAO;EAC5B;EACA,GAAI,iBACA,EAAE,cAAc,yBAAyB,eAAe,EAAE,GAC1D,EAAE;EACN,GAAI,MAAM,SAAS,EAAE,aAAa,MAAM,QAAQ,GAAG,EAAE;EACtD,CAAC"}

package/dist/internal/config.d.mts

@@ -1,10 +1,26 @@
-import { IngestTarget } from "../transport/http.mjs";
-
 //#region src/internal/config.d.ts
+interface IngestTarget {
+  headers: Headers;
+  url: string;
+}
+interface AuthHeaders {
+  headers: Headers;
+}
 declare function resolveTargets(): {
+  /**
+   * Base URL for OTLP exports — the trace/metric exporters append the
+   * sink path themselves. Avoids the kernel having to regex-strip
+   * `/v2/sink` off the configured URL to derive a base.
+   */
+  collectorBaseUrl: string;
   config: IngestTarget;
-  ingest: IngestTarget;
+  /**
+   * Identity headers shared across every collector-bound request
+   * (OTLP exporters, replay upload, session sync). One source of
+   * truth for auth + force-enable.
+   */
+  ingest: AuthHeaders;
   session: IngestTarget;
 };
 //#endregion
-export { resolveTargets };
+export { AuthHeaders, IngestTarget, resolveTargets };

package/dist/internal/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/internal/config.ts"],"mappings":";;;iBAyBgB,cAAA,CAAA;EACd,MAAA,EAAQ,YAAA;EACR,MAAA,EAAQ,YAAA;EACR,OAAA,EAAS,YAAA;AAAA"}
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/internal/config.ts"],"mappings":";UAKiB,YAAA;EACf,OAAA,EAAS,OAAA;EACT,GAAA;AAAA;AAAA,UAGe,WAAA;EACf,OAAA,EAAS,OAAA;AAAA;AAAA,iBAsBK,cAAA,CAAA;EA1BX;;AAGL;;;EA6BE,gBAAA;EACA,MAAA,EAAQ,YAAA;EAPM;;;;;EAad,MAAA,EAAQ,WAAA;EACR,OAAA,EAAS,YAAA;AAAA"}

package/dist/internal/config.mjs

@@ -1,30 +1,30 @@
+import { getGlobal } from "../util/global.mjs";
 import { API_PATHS, API_URL } from "@interfere/constants/api";
+import { resolveRoutePrefix } from "@interfere/constants/route-prefix";
 //#region src/internal/config.ts
-const DEFAULT_PROXY_URL = "/api/interfere";
-const DEFAULT_SESSION_PATH = "/v1/session";
-const DEFAULT_CONFIG_PATH = "/v1/config";
 function resolvePublicKey() {
-	const injected = globalThis["__INTERFERE_PUBLIC_KEY__"];
+	const injected = getGlobal("__INTERFERE_PUBLIC_KEY__");
 	if (injected) return injected;
 	if (typeof process !== "undefined") return process.env["INTERFERE_PUBLIC_KEY"] ?? void 0;
 }
+function isForceEnableActive() {
+	return !!getGlobal("__INTERFERE_FORCE_ENABLE__");
+}
 function resolveTargets() {
 	const publicKey = resolvePublicKey();
 	const headers = new Headers({ "content-type": "application/json" });
 	if (publicKey) headers.set("x-interfere-pub-token", publicKey);
-	const baseUrl = publicKey ? API_URL : DEFAULT_PROXY_URL;
-	const sessionPath = API_PATHS.SESSION ?? DEFAULT_SESSION_PATH;
+	if (isForceEnableActive()) headers.set("x-interfere-force-enable", "1");
+	const baseUrl = publicKey ? API_URL : resolveRoutePrefix();
 	return {
+		collectorBaseUrl: baseUrl,
 		config: {
-			url: `${baseUrl}${API_PATHS.CONFIG ?? DEFAULT_CONFIG_PATH}`,
-			headers
-		},
-		ingest: {
-			url: `${baseUrl}${API_PATHS.INGEST}`,
+			url: `${baseUrl}${API_PATHS.CONFIG}`,
 			headers
 		},
+		ingest: { headers },
 		session: {
-			url: `${baseUrl}${sessionPath}`,
+			url: `${baseUrl}${API_PATHS.SESSION}`,
 			headers
 		}
 	};

package/dist/internal/config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config.mjs","names":[],"sources":["../../src/internal/config.ts"],"sourcesContent":["import { API_PATHS, API_URL } from \"@interfere/constants/api\";\n\nimport type { IngestTarget } from \"../transport/http.js\";\n\nconst DEFAULT_PROXY_URL = \"/api/interfere\";\nconst DEFAULT_SESSION_PATH = \"/v1/session\";\nconst DEFAULT_CONFIG_PATH = \"/v1/config\";\n\nfunction resolvePublicKey(): string | undefined {\n  // Vite plugin injects the key onto globalThis at build time\n  const injected = (globalThis as Record<string, unknown>)[\n    \"__INTERFERE_PUBLIC_KEY__\"\n  ] as string | undefined;\n  if (injected) {\n    return injected;\n  }\n\n  // Node / webpack / Next.js: read from process.env\n  if (typeof process !== \"undefined\") {\n    return process.env[\"INTERFERE_PUBLIC_KEY\"] ?? undefined;\n  }\n\n  return;\n}\n\nexport function resolveTargets(): {\n  config: IngestTarget;\n  ingest: IngestTarget;\n  session: IngestTarget;\n} {\n  const publicKey = resolvePublicKey();\n  const headers = new Headers({ \"content-type\": \"application/json\" });\n  if (publicKey) {\n    headers.set(\"x-interfere-pub-token\", publicKey);\n  }\n\n  const baseUrl = publicKey ? API_URL : DEFAULT_PROXY_URL;\n  const sessionPath =\n    (API_PATHS as { SESSION?: string }).SESSION ?? DEFAULT_SESSION_PATH;\n  const configPath =\n    (API_PATHS as { CONFIG?: string }).CONFIG ?? DEFAULT_CONFIG_PATH;\n\n  return {\n    config: {\n      url: `${baseUrl}${configPath}`,\n      headers,\n    },\n    ingest: {\n      url: `${baseUrl}${API_PATHS.INGEST}`,\n      headers,\n    },\n    session: {\n      url: `${baseUrl}${sessionPath}`,\n      headers,\n    },\n  };\n}\n"],"mappings":";;AAIA,MAAM,oBAAoB;AAC1B,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB;AAE5B,SAAS,mBAAuC;CAE9C,MAAM,WAAY,WAChB;AAEF,KAAI,SACF,QAAO;AAIT,KAAI,OAAO,YAAY,YACrB,QAAO,QAAQ,IAAI,2BAA2B,KAAA;;AAMlD,SAAgB,iBAId;CACA,MAAM,YAAY,kBAAkB;CACpC,MAAM,UAAU,IAAI,QAAQ,EAAE,gBAAgB,oBAAoB,CAAC;AACnE,KAAI,UACF,SAAQ,IAAI,yBAAyB,UAAU;CAGjD,MAAM,UAAU,YAAY,UAAU;CACtC,MAAM,cACH,UAAmC,WAAW;AAIjD,QAAO;EACL,QAAQ;GACN,KAAK,GAAG,UAJT,UAAkC,UAAU;GAK3C;GACD;EACD,QAAQ;GACN,KAAK,GAAG,UAAU,UAAU;GAC5B;GACD;EACD,SAAS;GACP,KAAK,GAAG,UAAU;GAClB;GACD;EACF"}
+{"version":3,"file":"config.mjs","names":[],"sources":["../../src/internal/config.ts"],"sourcesContent":["import { API_PATHS, API_URL } from \"@interfere/constants/api\";\nimport { resolveRoutePrefix } from \"@interfere/constants/route-prefix\";\n\nimport { getGlobal } from \"../util/global.js\";\n\nexport interface IngestTarget {\n  headers: Headers;\n  url: string;\n}\n\nexport interface AuthHeaders {\n  headers: Headers;\n}\n\nfunction resolvePublicKey(): string | undefined {\n  // Vite plugin injects the key onto globalThis at build time\n  const injected = getGlobal<string>(\"__INTERFERE_PUBLIC_KEY__\");\n  if (injected) {\n    return injected;\n  }\n\n  // Node / webpack / Next.js: read from process.env\n  if (typeof process !== \"undefined\") {\n    return process.env[\"INTERFERE_PUBLIC_KEY\"] ?? undefined;\n  }\n\n  return;\n}\n\nfunction isForceEnableActive(): boolean {\n  return !!getGlobal<boolean>(\"__INTERFERE_FORCE_ENABLE__\");\n}\n\nexport function resolveTargets(): {\n  /**\n   * Base URL for OTLP exports — the trace/metric exporters append the\n   * sink path themselves. Avoids the kernel having to regex-strip\n   * `/v2/sink` off the configured URL to derive a base.\n   */\n  collectorBaseUrl: string;\n  config: IngestTarget;\n  /**\n   * Identity headers shared across every collector-bound request\n   * (OTLP exporters, replay upload, session sync). One source of\n   * truth for auth + force-enable.\n   */\n  ingest: AuthHeaders;\n  session: IngestTarget;\n} {\n  const publicKey = resolvePublicKey();\n  const headers = new Headers({ \"content-type\": \"application/json\" });\n  if (publicKey) {\n    headers.set(\"x-interfere-pub-token\", publicKey);\n  }\n  // Single chokepoint: every collector request (OTLP exporters, replay\n  // upload, session, config) reuses these headers, so the force-enable\n  // flag travels everywhere a customer event might. Production\n  // collectors drop on this header (ENG-1356).\n  if (isForceEnableActive()) {\n    headers.set(\"x-interfere-force-enable\", \"1\");\n  }\n\n  const baseUrl = publicKey ? API_URL : resolveRoutePrefix();\n\n  return {\n    collectorBaseUrl: baseUrl,\n    config: {\n      url: `${baseUrl}${API_PATHS.CONFIG}`,\n      headers,\n    },\n    ingest: { headers },\n    session: {\n      url: `${baseUrl}${API_PATHS.SESSION}`,\n      headers,\n    },\n  };\n}\n"],"mappings":";;;;AAcA,SAAS,mBAAuC;CAE9C,MAAM,WAAW,UAAkB,2BAA2B;CAC9D,IAAI,UACF,OAAO;CAIT,IAAI,OAAO,YAAY,aACrB,OAAO,QAAQ,IAAI,2BAA2B,KAAA;;AAMlD,SAAS,sBAA+B;CACtC,OAAO,CAAC,CAAC,UAAmB,6BAA6B;;AAG3D,SAAgB,iBAed;CACA,MAAM,YAAY,kBAAkB;CACpC,MAAM,UAAU,IAAI,QAAQ,EAAE,gBAAgB,oBAAoB,CAAC;CACnE,IAAI,WACF,QAAQ,IAAI,yBAAyB,UAAU;CAMjD,IAAI,qBAAqB,EACvB,QAAQ,IAAI,4BAA4B,IAAI;CAG9C,MAAM,UAAU,YAAY,UAAU,oBAAoB;CAE1D,OAAO;EACL,kBAAkB;EAClB,QAAQ;GACN,KAAK,GAAG,UAAU,UAAU;GAC5B;GACD;EACD,QAAQ,EAAE,SAAS;EACnB,SAAS;GACP,KAAK,GAAG,UAAU,UAAU;GAC5B;GACD;EACF"}

package/dist/internal/consent.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"consent.d.mts","names":[],"sources":["../../src/internal/consent.ts"],"mappings":";;;;cAQa,eAAA;EAAA,SAGoB,SAAA;EAAA,SAAA,MAAA;AAAA;AAAA,iBAYjB,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,eAAA;AAAA,iBAI1C,gBAAA,CACd,QAAA,EAAU,eAAA,EACV,YAAA,EAAc,YAAA;AAAA,iBASA,kBAAA,CACd,IAAA,EAAM,SAAA,EACN,YAAA,EAAc,YAAA;AAAA,iBAKA,qBAAA,CAAsB,OAAA,GAAU,YAAA,GAAe,YAAA;AAAA,iBAI/C,iBAAA,CACd,OAAA,EAAS,YAAA,SACT,IAAA,EAAM,YAAA"}
+{"version":3,"file":"consent.d.mts","names":[],"sources":["../../src/internal/consent.ts"],"mappings":";;;;cASa,eAAA;EAAA,SAGoB,SAAA;EAAA,SAAA,MAAA;AAAA;AAAA,iBAcjB,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,eAAA;AAAA,iBAI1C,gBAAA,CACd,QAAA,EAAU,eAAA,EACV,YAAA,EAAc,YAAA;AAAA,iBASA,kBAAA,CACd,IAAA,EAAM,SAAA,EACN,YAAA,EAAc,YAAA;AAAA,iBAKA,qBAAA,CAAsB,OAAA,GAAU,YAAA,GAAe,YAAA;AAAA,iBAI/C,iBAAA,CACd,OAAA,EAAS,YAAA,SACT,IAAA,EAAM,YAAA"}

package/dist/internal/consent.mjs

@@ -6,6 +6,7 @@ const DEFAULT_CONSENT = {
 };
 const PLUGIN_CONSENT_BY_KEY = Object.fromEntries(PLUGIN_MANIFEST.map((plugin) => [plugin.name, plugin.consentCategory]));
 const EVENT_CONSENT_BY_TYPE = Object.fromEntries(PLUGIN_MANIFEST.flatMap((plugin) => plugin.events.map((event) => [event.name, plugin.consentCategory])));
+const GATEABLE_CATEGORIES = Object.keys(DEFAULT_CONSENT);
 function getPluginConsentCategory(key) {
 	return PLUGIN_CONSENT_BY_KEY[key];
 }
@@ -19,7 +20,8 @@ function resolveGrantedConsent(consent) {
 	return consent ?? { ...DEFAULT_CONSENT };
 }
 function hasConsentChanged(current, next) {
-	return current?.analytics !== next?.analytics || current?.replay !== next?.replay;
+	for (const category of GATEABLE_CATEGORIES) if (current?.[category] !== next?.[category]) return true;
+	return false;
 }
 //#endregion
 export { DEFAULT_CONSENT, getPluginConsentCategory, hasConsentChanged, isConsentAllowed, resolveGrantedConsent, shouldCaptureEvent };

package/dist/internal/consent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"consent.mjs","names":[],"sources":["../../src/internal/consent.ts"],"sourcesContent":["import type { EventType } from \"@interfere/types/sdk/envelope\";\nimport {\n  type ConsentCategory,\n  type ConsentState,\n  PLUGIN_MANIFEST,\n  type PluginKey,\n} from \"@interfere/types/sdk/plugins/manifest\";\n\nexport const DEFAULT_CONSENT = {\n  analytics: true,\n  replay: true,\n} as const satisfies ConsentState;\n\nconst PLUGIN_CONSENT_BY_KEY = Object.fromEntries(\n  PLUGIN_MANIFEST.map((plugin) => [plugin.name, plugin.consentCategory])\n) as Record<PluginKey, ConsentCategory>;\n\nconst EVENT_CONSENT_BY_TYPE = Object.fromEntries(\n  PLUGIN_MANIFEST.flatMap((plugin) =>\n    plugin.events.map((event) => [event.name, plugin.consentCategory] as const)\n  )\n) as Record<EventType, ConsentCategory>;\n\nexport function getPluginConsentCategory(key: PluginKey): ConsentCategory {\n  return PLUGIN_CONSENT_BY_KEY[key];\n}\n\nexport function isConsentAllowed(\n  category: ConsentCategory,\n  consentState: ConsentState | null\n): boolean {\n  return (\n    category === \"necessary\" ||\n    consentState === null ||\n    consentState[category] === true\n  );\n}\n\nexport function shouldCaptureEvent(\n  type: EventType,\n  consentState: ConsentState | null\n): boolean {\n  return isConsentAllowed(EVENT_CONSENT_BY_TYPE[type], consentState);\n}\n\nexport function resolveGrantedConsent(consent?: ConsentState): ConsentState {\n  return consent ?? { ...DEFAULT_CONSENT };\n}\n\nexport function hasConsentChanged(\n  current: ConsentState | null,\n  next: ConsentState | null\n): boolean {\n  return (\n    current?.analytics !== next?.analytics || current?.replay !== next?.replay\n  );\n}\n"],"mappings":";;AAQA,MAAa,kBAAkB;CAC7B,WAAW;CACX,QAAQ;CACT;AAED,MAAM,wBAAwB,OAAO,YACnC,gBAAgB,KAAK,WAAW,CAAC,OAAO,MAAM,OAAO,gBAAgB,CAAC,CACvE;AAED,MAAM,wBAAwB,OAAO,YACnC,gBAAgB,SAAS,WACvB,OAAO,OAAO,KAAK,UAAU,CAAC,MAAM,MAAM,OAAO,gBAAgB,CAAU,CAC5E,CACF;AAED,SAAgB,yBAAyB,KAAiC;AACxE,QAAO,sBAAsB;;AAG/B,SAAgB,iBACd,UACA,cACS;AACT,QACE,aAAa,eACb,iBAAiB,QACjB,aAAa,cAAc;;AAI/B,SAAgB,mBACd,MACA,cACS;AACT,QAAO,iBAAiB,sBAAsB,OAAO,aAAa;;AAGpE,SAAgB,sBAAsB,SAAsC;AAC1E,QAAO,WAAW,EAAE,GAAG,iBAAiB;;AAG1C,SAAgB,kBACd,SACA,MACS;AACT,QACE,SAAS,cAAc,MAAM,aAAa,SAAS,WAAW,MAAM"}
+{"version":3,"file":"consent.mjs","names":[],"sources":["../../src/internal/consent.ts"],"sourcesContent":["import type { EventType } from \"@interfere/types/sdk/envelope\";\nimport {\n  type ConsentCategory,\n  type ConsentState,\n  type GateableCategory,\n  PLUGIN_MANIFEST,\n  type PluginKey,\n} from \"@interfere/types/sdk/plugins/manifest\";\n\nexport const DEFAULT_CONSENT = {\n  analytics: true,\n  replay: true,\n} as const satisfies ConsentState;\n\nconst PLUGIN_CONSENT_BY_KEY = Object.fromEntries(\n  PLUGIN_MANIFEST.map((plugin) => [plugin.name, plugin.consentCategory])\n) as Record<PluginKey, ConsentCategory>;\n\nconst EVENT_CONSENT_BY_TYPE = Object.fromEntries(\n  PLUGIN_MANIFEST.flatMap((plugin) =>\n    plugin.events.map((event) => [event.name, plugin.consentCategory] as const)\n  )\n) as Record<EventType, ConsentCategory>;\n\nconst GATEABLE_CATEGORIES = Object.keys(DEFAULT_CONSENT) as GateableCategory[];\n\nexport function getPluginConsentCategory(key: PluginKey): ConsentCategory {\n  return PLUGIN_CONSENT_BY_KEY[key];\n}\n\nexport function isConsentAllowed(\n  category: ConsentCategory,\n  consentState: ConsentState | null\n): boolean {\n  return (\n    category === \"necessary\" ||\n    consentState === null ||\n    consentState[category] === true\n  );\n}\n\nexport function shouldCaptureEvent(\n  type: EventType,\n  consentState: ConsentState | null\n): boolean {\n  return isConsentAllowed(EVENT_CONSENT_BY_TYPE[type], consentState);\n}\n\nexport function resolveGrantedConsent(consent?: ConsentState): ConsentState {\n  return consent ?? { ...DEFAULT_CONSENT };\n}\n\nexport function hasConsentChanged(\n  current: ConsentState | null,\n  next: ConsentState | null\n): boolean {\n  for (const category of GATEABLE_CATEGORIES) {\n    if (current?.[category] !== next?.[category]) {\n      return true;\n    }\n  }\n  return false;\n}\n"],"mappings":";;AASA,MAAa,kBAAkB;CAC7B,WAAW;CACX,QAAQ;CACT;AAED,MAAM,wBAAwB,OAAO,YACnC,gBAAgB,KAAK,WAAW,CAAC,OAAO,MAAM,OAAO,gBAAgB,CAAC,CACvE;AAED,MAAM,wBAAwB,OAAO,YACnC,gBAAgB,SAAS,WACvB,OAAO,OAAO,KAAK,UAAU,CAAC,MAAM,MAAM,OAAO,gBAAgB,CAAU,CAC5E,CACF;AAED,MAAM,sBAAsB,OAAO,KAAK,gBAAgB;AAExD,SAAgB,yBAAyB,KAAiC;CACxE,OAAO,sBAAsB;;AAG/B,SAAgB,iBACd,UACA,cACS;CACT,OACE,aAAa,eACb,iBAAiB,QACjB,aAAa,cAAc;;AAI/B,SAAgB,mBACd,MACA,cACS;CACT,OAAO,iBAAiB,sBAAsB,OAAO,aAAa;;AAGpE,SAAgB,sBAAsB,SAAsC;CAC1E,OAAO,WAAW,EAAE,GAAG,iBAAiB;;AAG1C,SAAgB,kBACd,SACA,MACS;CACT,KAAK,MAAM,YAAY,qBACrB,IAAI,UAAU,cAAc,OAAO,WACjC,OAAO;CAGX,OAAO"}