@interfere/react 9.0.2 → 10.0.1-canary.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,KAAc"}

package/dist/api.mjs

@@ -0,0 +1 @@
+import{activeKernel}from"./internal/kernel-registry.mjs";import{MECHANISM_TYPE,toError,toException}from"@interfere/types/sdk/errors";import{SpanStatusCode,trace}from"@opentelemetry/api";function tracer(){return trace.getTracer(`@interfere/react`)}function isPromise(value){return!!value&&(typeof value==`object`||typeof value==`function`)&&typeof value.then==`function`}function span(name,fn,options){return tracer().startActiveSpan(name,options??{},s=>{try{let result=fn(s);return isPromise(result)?result.then(value=>(s.end(),value),err=>{let e=toError(err);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),err}):(s.end(),result)}catch(err){let e=toError(err);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),err}})}function capture(error){activeKernel()?.recordException(toException(error),{mechanism:{type:MECHANISM_TYPE.manual.capture,handled:!0}})}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":"0LAiBA,SAAS,QAAS,CAChB,OAAO,MAAM,UAAU,kBAAW,CACpC,CAEA,SAAS,UAAa,MAAqC,CACzD,MACE,CAAC,CAAC,QACD,OAAO,OAAU,UAAY,OAAO,OAAU,aAC/C,OAAQ,MAA6B,MAAS,UAElD,CAYA,SAAgB,KACd,KACA,GACA,QACG,CACH,OAAO,OAAO,EAAE,gBAAgB,KAAM,SAAW,CAAC,EAAI,GAAS,CAC7D,GAAI,CACF,IAAM,OAAS,GAAG,CAAC,EAiBnB,OAhBI,UAAa,MAAM,EACd,OAAO,KACX,QACC,EAAE,IAAI,EACC,OAER,KAAiB,CAChB,IAAM,EAAI,QAAQ,GAAG,EAIrB,MAHA,EAAE,gBAAgB,CAAC,EACnB,EAAE,UAAU,CAAE,KAAM,eAAe,MAAO,QAAS,EAAE,OAAQ,CAAC,EAC9D,EAAE,IAAI,EACA,GACR,CACF,GAEF,EAAE,IAAI,EACC,OACT,OAAS,IAAK,CACZ,IAAM,EAAI,QAAQ,GAAG,EAIrB,MAHA,EAAE,gBAAgB,CAAC,EACnB,EAAE,UAAU,CAAE,KAAM,eAAe,MAAO,QAAS,EAAE,OAAQ,CAAC,EAC9D,EAAE,IAAI,EACA,GACR,CACF,CAAC,CACH,CAUA,SAAgB,QAAQ,MAAsB,CAC5C,aAAa,GAAG,gBAAgB,YAAY,KAAK,EAAG,CAClD,UAAW,CAAE,KAAM,eAAe,OAAO,QAAS,QAAS,EAAK,CAClE,CAAC,CACH"}

package/dist/error-boundary.d.mts

@@ -1,4 +1,5 @@
-import { Component, ErrorInfo, ReactNode } from "react";
+import { InterfereContext, InterfereContextValue } from "./internal/react-context.mjs";
+import { Component, ContextType, ErrorInfo, ReactNode } from "react";
 
 //#region src/error-boundary.d.ts
 interface ErrorBoundaryProps {
@@ -11,15 +12,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: import("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,KAAK;AAAA;;;;;;;;;cAWD,aAAA,SAAsB,SAAA,CACjC,kBAAA,EACA,kBAAA;EAAA,OAEgB,WAAA,kBAAW,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,39 +1 @@
-"use client";
-import { captureReactError } from "./internal/capture.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.
-*
-* Class component required — React has no hook-based error boundary API.
-*/
-var ErrorBoundary = class extends Component {
-	state = { error: null };
-	static getDerivedStateFromError(error) {
-		return { error };
-	}
-	componentDidCatch(error, info) {
-		captureReactError(error, info.componentStack, {
-			type: MECHANISM_TYPE.react.errorBoundary,
-			handled: true
-		});
-		this.props.onError?.(error, info);
-	}
-	reset = () => {
-		this.setState({ error: null });
-	};
-	render() {
-		const { error } = this.state;
-		if (error) {
-			const { fallback } = this.props;
-			if (typeof fallback === "function") return fallback(error, this.reset);
-			return fallback ?? null;
-		}
-		return this.props.children;
-	}
-};
-//#endregion
-export { ErrorBoundary };
+"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";var ErrorBoundary=class extends Component{static contextType=InterfereContext;state={error:null};static getDerivedStateFromError(error){return{error}}componentDidCatch(error,info){captureReactError(this.context?.kernel??null,error,info.componentStack,{type:MECHANISM_TYPE.react.errorBoundary,handled:!0}),this.props.onError?.(error,info)}reset=()=>{this.setState({error:null})};render(){let{error}=this.state;if(error){let{fallback}=this.props;return typeof fallback==`function`?fallback(error,this.reset):fallback??null}return this.props.children}};export{ErrorBoundary};

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":"mNAgCA,IAAa,cAAb,cAAmC,SAGjC,CACA,OAAgB,YAAc,iBAG9B,MAAqC,CAAE,MAAO,IAAK,EAEnD,OAAO,yBAAyB,MAAkC,CAChE,MAAO,CAAE,KAAM,CACjB,CAEA,kBACE,MACA,KACA,CACA,kBACE,KAAK,SAAS,QAAU,KACxB,MACA,KAAK,eACL,CACE,KAAM,eAAe,MAAM,cAC3B,QAAS,EACX,CACF,EAEA,KAAK,MAAM,UAAU,MAAO,IAAI,CAClC,CAEA,UAA+B,CAC7B,KAAK,SAAS,CAAE,MAAO,IAAK,CAAC,CAC/B,EAEA,QAAkB,CAChB,GAAM,CAAE,OAAU,KAAK,MAEvB,GAAI,MAAO,CACT,GAAM,CAAE,UAAa,KAAK,MAI1B,OAHI,OAAO,UAAa,WACf,SAAS,MAAO,KAAK,KAAK,EAE5B,UAAY,IACrB,CAEA,OAAO,KAAK,MAAM,QACpB,CACF"}

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,OAAO,CAAC,cAAA"}

package/dist/internal/browser-context.mjs

@@ -0,0 +1 @@
+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";const NOT_A_BRAND_REGEX=/not.a.brand/i,HIGH_ENTROPY_HINTS=[`bitness`,`platformVersion`,`fullVersionList`];async function getDeviceMetadata(){if(typeof navigator>`u`)return null;let uaData=navigator.userAgentData,[parsed,hints]=await Promise.all([UAParser(navigator.userAgent,InApps).withClientHints(),uaData?.getHighEntropyValues?uaData.getHighEntropyValues(HIGH_ENTROPY_HINTS).catch(()=>({})):Promise.resolve({})]);if(!parsed)return null;let 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;let{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()}}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":"4KA0BA,MAAM,kBAAoB,eACpB,mBAAqB,CAAC,UAAW,kBAAmB,iBAAiB,EAE3E,eAAe,mBAAoD,CACjE,GAAI,OAAO,UAAc,IACvB,OAAO,KAGT,IAAM,OAAU,UACb,cAYG,CAAC,OAAQ,OAAS,MAAM,QAAQ,IAAI,CACxC,SAAS,UAAU,UAAW,MAAM,EAAE,gBAAgB,EACtD,QAAQ,qBACJ,OACG,qBAAqB,kBAAkB,EACvC,WAAgC,CAAC,EAAE,EACtC,QAAQ,QAA2B,CAAC,CAAC,CAC3C,CAAC,EAED,GAAI,CAAC,OACH,OAAO,KAGT,IAAM,YAAc,MAAM,iBAAiB,KACxC,GAAM,CAAC,kBAAkB,KAAK,EAAE,KAAK,CACxC,GAAG,QAEH,MAAO,CACL,GAAG,OACH,QAAS,CACP,GAAG,OAAO,QACV,GAAI,YAAc,CAAE,WAAY,EAAI,CAAC,CACvC,EACA,IAAK,CACH,GAAG,OAAO,IACV,GAAI,MAAM,QAAU,CAAE,QAAS,MAAM,OAAQ,EAAI,CAAC,CACpD,EACA,GAAI,CACF,GAAG,OAAO,GACV,GAAI,MAAM,gBAAkB,CAAE,YAAa,MAAM,eAAgB,EAAI,CAAC,CACxE,EACA,SAAU,WAAW,UAAU,SAAS,CAC1C,CACF,CAEA,SAAS,oBAA6C,CACpD,GACE,CAAC,OAAO,UAAW,OAAO,OAAQ,OAAO,UAAU,EAAE,KAClD,GAAM,IAAM,WACf,EAEA,OAAO,KAGT,GAAM,CAAE,UAAa,UAErB,MAAO,CACL,SACA,SAAU,KAAK,eAAe,EAAE,gBAAgB,EAAE,SAClD,QAAS,CACP,OAAQ,CACN,OAAQ,OAAO,YACf,MAAO,OAAO,WACd,YAAa,OAAO,aAAa,IACnC,CACF,CACF,CACF,CAEA,eAAsB,gBAA0C,CAC9D,MAAO,CACL,QAAS,UACT,QAAS,mBAAmB,EAC5B,OAAQ,MAAM,kBAAkB,CAClC,CACF"}

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

@@ -1,4 +1,5 @@
-import { Component, ReactNode } from "react";
+import { InterfereContext, InterfereContextValue } from "./react-context.mjs";
+import { Component, ContextType, ReactNode } from "react";
 
 //#region src/internal/capture-boundary.d.ts
 interface CaptureBoundaryProps {
@@ -31,6 +32,8 @@ interface CaptureBoundaryState {
  * captured the error but did not render a fallback — propagation continues.
  */
 declare class CaptureBoundary extends Component<CaptureBoundaryProps, CaptureBoundaryState> {
+  static contextType: import("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,SAAS;AAAA;AAAA,UAGX,oBAAA;EACR,KAAA,EAAO,KAAK;AAAA;AAJO;AAAA;;;;AAIP;AA0Bd;;;;;;;;;;;;;;;;;AA9BqB,cA8BR,eAAA,SAAwB,SAAA,CACnC,oBAAA,EACA,oBAAA;EAAA,OAEgB,WAAA,kBAAW,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,44 +1 @@
-"use client";
-import { captureReactError } from "./capture.mjs";
-import { MECHANISM_TYPE } from "@interfere/types/sdk/errors";
-import { Component } from "react";
-//#region src/internal/capture-boundary.tsx
-/**
-* Internal boundary used by `<InterfereProvider>` to capture render-phase
-* React errors without changing the app's UX.
-*
-* Unlike the public `ErrorBoundary`, this boundary always re-throws the
-* captured error in its `render()` so upstream boundaries — the customer's
-* own `ErrorBoundary`, Next.js's `error.tsx` / `global-error.tsx`, or React's
-* default unmount — keep control of what the user sees. The net effect:
-* zero visual change, full capture coverage for any render-phase error in
-* the subtree.
-*
-* Capture happens inside `getDerivedStateFromError` rather than
-* `componentDidCatch` because `componentDidCatch` does not fire on a boundary
-* that re-throws in render — React considers such a boundary to have failed
-* and skips its commit-phase lifecycle. The trade-off: we don't get
-* `errorInfo.componentStack` in this capture. Callers who want the component
-* tree should use the public `ErrorBoundary` (which renders a fallback and
-* therefore receives `componentDidCatch`), or pass
-* {@link reactErrorHandler} to `createRoot()`.
-*
-* `mechanism.handled` is `false` because from Interfere's perspective we
-* captured the error but did not render a fallback — propagation continues.
-*/
-var CaptureBoundary = class extends Component {
-	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;
-		return this.props.children;
-	}
-};
-//#endregion
-export { CaptureBoundary };
+"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";var CaptureBoundary=class extends Component{static contextType=InterfereContext;state={error:null};static getDerivedStateFromError(error){return{error}}render(){if(this.state.error)throw captureReactError(this.context?.kernel??null,this.state.error,null,{type:MECHANISM_TYPE.react.captureBoundary,handled:!1}),this.state.error;return this.props.children}};export{CaptureBoundary};

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":"iMAwCA,IAAa,gBAAb,cAAqC,SAGnC,CACA,OAAgB,YAAc,iBAG9B,MAAuC,CAAE,MAAO,IAAK,EAErD,OAAO,yBAAyB,MAAoC,CAClE,MAAO,CAAE,KAAM,CACjB,CAEA,QAA6B,CAC3B,GAAI,KAAK,MAAM,MAUb,MAJA,kBAAkB,KAAK,SAAS,QAAU,KAAM,KAAK,MAAM,MAAO,KAAM,CACtE,KAAM,eAAe,MAAM,gBAC3B,QAAS,EACX,CAAC,EACK,KAAK,MAAM,MAEnB,OAAO,KAAK,MAAM,QACpB,CACF"}

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 @@
-import { seen } from "./errors.mjs";
-import { getClient } from "./client.mjs";
-import { parseReactComponentStack, shouldDropBrowserExtensionNoise, toExceptions } 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.
-*
-* Swallows errors from `getClient()` so callers can run before the SDK is
-* initialized (e.g. an error boundary catching a pre-init crash).
-*/
-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 {}
-}
-//#endregion
-export { captureReactError };
+import{parseReactComponentStack}from"@interfere/types/sdk/errors";function captureReactError(kernel,error,componentStack,mechanism){kernel&&kernel.recordException(error,{mechanism,...componentStack?{appendFrames:parseReactComponentStack(componentStack)}:{},...error.digest?{errorDigest:error.digest}:{}})}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":"kEAoBA,SAAgB,kBACd,OACA,MACA,eACA,UACM,CACD,QAGL,OAAO,gBAAgB,MAAO,CAC5B,UACA,GAAI,eACA,CAAE,aAAc,yBAAyB,cAAc,CAAE,EACzD,CAAC,EACL,GAAI,MAAM,OAAS,CAAE,YAAa,MAAM,MAAO,EAAI,CAAC,CACtD,CAAC,CACH"}

package/dist/internal/config.d.mts

@@ -1,10 +1,28 @@
-import { IngestTarget } from "../transport/http.mjs";
-
 //#region src/internal/config.d.ts
+interface IngestTarget {
+  headers: Headers;
+  url: string;
+}
+interface AuthHeaders {
+  headers: Headers;
+}
+declare function withQueryParam(url: string, key: string, value: string): string;
+declare function appendPathBeforeQuery(url: string, path: string): string;
 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, appendPathBeforeQuery, resolveTargets, withQueryParam };

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":";UAUiB,YAAA;EACf,OAAA,EAAS,OAAO;EAChB,GAAA;AAAA;AAAA,UAGe,WAAA;EACf,OAAA,EAAS,OAAO;AAAA;AAAA,iBA0CF,cAAA,CACd,GAAA,UACA,GAAA,UACA,KAAA;AAAA,iBAWc,qBAAA,CAAsB,GAAA,UAAa,IAAY;AAAA,iBAO/C,cAAA,CAAA;EAhEC;;;;AACC;EAqEhB,gBAAA;EACA,MAAA,EAAQ,YAAA;;;;;;EAMR,MAAA,EAAQ,WAAA;EACR,OAAA,EAAS,YAAA;AAAA"}

package/dist/internal/config.mjs

@@ -1,33 +1 @@
-import { API_PATHS, API_URL } from "@interfere/constants/api";
-//#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__"];
-	if (injected) return injected;
-	if (typeof process !== "undefined") return process.env["INTERFERE_PUBLIC_KEY"] ?? void 0;
-}
-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;
-	return {
-		config: {
-			url: `${baseUrl}${API_PATHS.CONFIG ?? DEFAULT_CONFIG_PATH}`,
-			headers
-		},
-		ingest: {
-			url: `${baseUrl}${API_PATHS.INGEST}`,
-			headers
-		},
-		session: {
-			url: `${baseUrl}${sessionPath}`,
-			headers
-		}
-	};
-}
-//#endregion
-export { resolveTargets };
+import{getGlobal}from"../util/global.mjs";import{API_PATHS,API_URL}from"@interfere/constants/api";import{resolveRoutePrefix}from"@interfere/constants/route-prefix";const TRAILING_SLASH_RE=/\/$/,RELATIVE_URL_BASE=`https://interfere.local`;function resolvePublicKey(){let injected=getGlobal(`__INTERFERE_PUBLIC_KEY__`);if(injected)return injected;if(typeof process<`u`)return process.env.INTERFERE_PUBLIC_KEY??void 0}function resolveApiUrlOverride(){let injected=getGlobal(`__INTERFERE_API_URL__`);if(injected)return injected}function isForceEnableActive(){return!!getGlobal(`__INTERFERE_FORCE_ENABLE__`)}function isProxyModeActive(){return!!getGlobal(`__INTERFERE_PROXY_MODE__`)}function serializeUrl(input,url){return input.startsWith(`/`)?`${url.pathname}${url.search}`:url.toString()}function withQueryParam(url,key,value){let next=new URL(url,RELATIVE_URL_BASE);return next.searchParams.set(key,value),serializeUrl(url,next)}function appendPublicKey(url,publicKey){return publicKey?withQueryParam(url,`pk`,publicKey):url}function appendPathBeforeQuery(url,path){let next=new URL(url,RELATIVE_URL_BASE),suffix=path.startsWith(`/`)?path:`/${path}`;return next.pathname=`${next.pathname.replace(TRAILING_SLASH_RE,``)}${suffix}`,serializeUrl(url,next)}function resolveTargets(){let publicKey=resolvePublicKey(),headers=new Headers({"content-type":`application/json`});isForceEnableActive()&&headers.set(`x-interfere-force-enable`,`1`);let baseUrl=publicKey&&!isProxyModeActive()?resolveApiUrlOverride()??API_URL:resolveRoutePrefix();return{collectorBaseUrl:appendPublicKey(baseUrl,publicKey),config:{url:appendPublicKey(`${baseUrl}${API_PATHS.CONFIG}`,publicKey),headers},ingest:{headers},session:{url:appendPublicKey(`${baseUrl}${API_PATHS.SESSION}`,publicKey),headers}}}export{appendPathBeforeQuery,resolveTargets,withQueryParam};

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\nconst PUBLIC_KEY_QUERY = \"pk\";\nconst PROXY_MODE_GLOBAL = \"__INTERFERE_PROXY_MODE__\";\nconst TRAILING_SLASH_RE = /\\/$/;\nconst RELATIVE_URL_BASE = \"https://interfere.local\";\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 resolveApiUrlOverride(): string | undefined {\n  const injected = getGlobal<string>(\"__INTERFERE_API_URL__\");\n  if (injected) {\n    return injected;\n  }\n\n  return;\n}\n\nfunction isForceEnableActive(): boolean {\n  return !!getGlobal<boolean>(\"__INTERFERE_FORCE_ENABLE__\");\n}\n\nfunction isProxyModeActive(): boolean {\n  return !!getGlobal<boolean>(PROXY_MODE_GLOBAL);\n}\n\nfunction serializeUrl(input: string, url: URL): string {\n  if (input.startsWith(\"/\")) {\n    return `${url.pathname}${url.search}`;\n  }\n  return url.toString();\n}\n\nexport function withQueryParam(\n  url: string,\n  key: string,\n  value: string\n): string {\n  const next = new URL(url, RELATIVE_URL_BASE);\n  next.searchParams.set(key, value);\n  return serializeUrl(url, next);\n}\n\nfunction appendPublicKey(url: string, publicKey: string | undefined): string {\n  return publicKey ? withQueryParam(url, PUBLIC_KEY_QUERY, publicKey) : url;\n}\n\nexport function appendPathBeforeQuery(url: string, path: string): string {\n  const next = new URL(url, RELATIVE_URL_BASE);\n  const suffix = path.startsWith(\"/\") ? path : `/${path}`;\n  next.pathname = `${next.pathname.replace(TRAILING_SLASH_RE, \"\")}${suffix}`;\n  return serializeUrl(url, next);\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  // 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 =\n    publicKey && !isProxyModeActive()\n      ? (resolveApiUrlOverride() ?? API_URL)\n      : resolveRoutePrefix();\n  const authenticatedBaseUrl = appendPublicKey(baseUrl, publicKey);\n\n  return {\n    collectorBaseUrl: authenticatedBaseUrl,\n    config: {\n      url: appendPublicKey(`${baseUrl}${API_PATHS.CONFIG}`, publicKey),\n      headers,\n    },\n    ingest: { headers },\n    session: {\n      url: appendPublicKey(`${baseUrl}${API_PATHS.SESSION}`, publicKey),\n      headers,\n    },\n  };\n}\n"],"mappings":"oKAKA,MAEM,kBAAoB,MACpB,kBAAoB,0BAW1B,SAAS,kBAAuC,CAE9C,IAAM,SAAW,UAAkB,0BAA0B,EAC7D,GAAI,SACF,OAAO,SAIT,GAAI,OAAO,QAAY,IACrB,OAAO,QAAQ,IAAI,sBAA2B,IAAA,EAIlD,CAEA,SAAS,uBAA4C,CACnD,IAAM,SAAW,UAAkB,uBAAuB,EAC1D,GAAI,SACF,OAAO,QAIX,CAEA,SAAS,qBAA+B,CACtC,MAAO,CAAC,CAAC,UAAmB,4BAA4B,CAC1D,CAEA,SAAS,mBAA6B,CACpC,MAAO,CAAC,CAAC,UAAmB,0BAAiB,CAC/C,CAEA,SAAS,aAAa,MAAe,IAAkB,CAIrD,OAHI,MAAM,WAAW,GAAG,EACf,GAAG,IAAI,WAAW,IAAI,SAExB,IAAI,SAAS,CACtB,CAEA,SAAgB,eACd,IACA,IACA,MACQ,CACR,IAAM,KAAO,IAAI,IAAI,IAAK,iBAAiB,EAE3C,OADA,KAAK,aAAa,IAAI,IAAK,KAAK,EACzB,aAAa,IAAK,IAAI,CAC/B,CAEA,SAAS,gBAAgB,IAAa,UAAuC,CAC3E,OAAO,UAAY,eAAe,IAAK,KAAkB,SAAS,EAAI,GACxE,CAEA,SAAgB,sBAAsB,IAAa,KAAsB,CACvE,IAAM,KAAO,IAAI,IAAI,IAAK,iBAAiB,EACrC,OAAS,KAAK,WAAW,GAAG,EAAI,KAAO,IAAI,OAEjD,MADA,MAAK,SAAW,GAAG,KAAK,SAAS,QAAQ,kBAAmB,EAAE,IAAI,SAC3D,aAAa,IAAK,IAAI,CAC/B,CAEA,SAAgB,gBAed,CACA,IAAM,UAAY,iBAAiB,EAC7B,QAAU,IAAI,QAAQ,CAAE,eAAgB,kBAAmB,CAAC,EAK9D,oBAAoB,GACtB,QAAQ,IAAI,2BAA4B,GAAG,EAG7C,IAAM,QACJ,WAAa,CAAC,kBAAkB,EAC3B,sBAAsB,GAAK,QAC5B,mBAAmB,EAGzB,MAAO,CACL,iBAH2B,gBAAgB,QAAS,SAGf,EACrC,OAAQ,CACN,IAAK,gBAAgB,GAAG,UAAU,UAAU,SAAU,SAAS,EAC/D,OACF,EACA,OAAQ,CAAE,OAAQ,EAClB,QAAS,CACP,IAAK,gBAAgB,GAAG,UAAU,UAAU,UAAW,SAAS,EAChE,OACF,CACF,CACF"}

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,eAAe;AAAA,iBAIzD,gBAAA,CACd,QAAA,EAAU,eAAA,EACV,YAAA,EAAc,YAAY;AAAA,iBASZ,kBAAA,CACd,IAAA,EAAM,SAAA,EACN,YAAA,EAAc,YAAY;AAAA,iBAKZ,qBAAA,CAAsB,OAAA,GAAU,YAAA,GAAe,YAAY;AAAA,iBAI3D,iBAAA,CACd,OAAA,EAAS,YAAA,SACT,IAAA,EAAM,YAAY"}

package/dist/internal/consent.mjs

@@ -1,25 +1 @@
-import { PLUGIN_MANIFEST } from "@interfere/types/sdk/plugins/manifest";
-//#region src/internal/consent.ts
-const DEFAULT_CONSENT = {
-	analytics: true,
-	replay: true
-};
-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])));
-function getPluginConsentCategory(key) {
-	return PLUGIN_CONSENT_BY_KEY[key];
-}
-function isConsentAllowed(category, consentState) {
-	return category === "necessary" || consentState === null || consentState[category] === true;
-}
-function shouldCaptureEvent(type, consentState) {
-	return isConsentAllowed(EVENT_CONSENT_BY_TYPE[type], consentState);
-}
-function resolveGrantedConsent(consent) {
-	return consent ?? { ...DEFAULT_CONSENT };
-}
-function hasConsentChanged(current, next) {
-	return current?.analytics !== next?.analytics || current?.replay !== next?.replay;
-}
-//#endregion
-export { DEFAULT_CONSENT, getPluginConsentCategory, hasConsentChanged, isConsentAllowed, resolveGrantedConsent, shouldCaptureEvent };
+import{PLUGIN_MANIFEST}from"@interfere/types/sdk/plugins/manifest";const DEFAULT_CONSENT={analytics:!0,replay:!0},PLUGIN_CONSENT_BY_KEY=Object.fromEntries(PLUGIN_MANIFEST.map(plugin=>[plugin.name,plugin.consentCategory])),EVENT_CONSENT_BY_TYPE=Object.fromEntries(PLUGIN_MANIFEST.flatMap(plugin=>plugin.events.map(event=>[event.name,plugin.consentCategory]))),GATEABLE_CATEGORIES=Object.keys(DEFAULT_CONSENT);function getPluginConsentCategory(key){return PLUGIN_CONSENT_BY_KEY[key]}function isConsentAllowed(category,consentState){return category===`necessary`||consentState===null||consentState[category]===!0}function shouldCaptureEvent(type,consentState){return isConsentAllowed(EVENT_CONSENT_BY_TYPE[type],consentState)}function resolveGrantedConsent(consent){return consent??{...DEFAULT_CONSENT}}function hasConsentChanged(current,next){for(let category of GATEABLE_CATEGORIES)if(current?.[category]!==next?.[category])return!0;return!1}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":"mEASA,MAAa,gBAAkB,CAC7B,UAAW,GACX,OAAQ,EACV,EAEM,sBAAwB,OAAO,YACnC,gBAAgB,IAAK,QAAW,CAAC,OAAO,KAAM,OAAO,eAAe,CAAC,CACvE,EAEM,sBAAwB,OAAO,YACnC,gBAAgB,QAAS,QACvB,OAAO,OAAO,IAAK,OAAU,CAAC,MAAM,KAAM,OAAO,eAAe,CAAU,CAC5E,CACF,EAEM,oBAAsB,OAAO,KAAK,eAAe,EAEvD,SAAgB,yBAAyB,IAAiC,CACxE,OAAO,sBAAsB,IAC/B,CAEA,SAAgB,iBACd,SACA,aACS,CACT,OACE,WAAa,aACb,eAAiB,MACjB,aAAa,YAAc,EAE/B,CAEA,SAAgB,mBACd,KACA,aACS,CACT,OAAO,iBAAiB,sBAAsB,MAAO,YAAY,CACnE,CAEA,SAAgB,sBAAsB,QAAsC,CAC1E,OAAO,SAAW,CAAE,GAAG,eAAgB,CACzC,CAEA,SAAgB,kBACd,QACA,KACS,CACT,IAAK,IAAM,YAAY,oBACrB,GAAI,UAAU,YAAc,OAAO,UACjC,MAAO,GAGX,MAAO,EACT"}

package/dist/internal/console-patch.d.mts

@@ -0,0 +1,19 @@
+//#region src/internal/console-patch.d.ts
+/**
+ * Single point of `console.{debug,log,info,warn,error}` patching. The
+ * errors plugin and the logs plugin both want to observe console calls;
+ * before this consolidation, each patched independently and the
+ * resulting wrap-order coupling made teardown leaky.
+ *
+ * Now: a single set of patched methods is installed on first
+ * subscription, fans out to every subscriber, and is uninstalled on the
+ * last unsubscription. Handlers never wrap each other; they observe.
+ */
+declare const CONSOLE_LEVELS: readonly ["debug", "log", "info", "warn", "error"];
+type ConsoleLevel = (typeof CONSOLE_LEVELS)[number];
+type ConsoleHandler = (level: ConsoleLevel, args: unknown[]) => void;
+declare function onConsoleCall(handler: ConsoleHandler): () => void;
+/** Test hook — drops every handler and restores originals. */
+declare function _resetConsolePatchForTests(): void;
+//#endregion
+export { CONSOLE_LEVELS, ConsoleHandler, ConsoleLevel, _resetConsolePatchForTests, onConsoleCall };

package/dist/internal/console-patch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-patch.d.mts","names":[],"sources":["../../src/internal/console-patch.ts"],"mappings":";;AAUA;;;;AAMU;AAEV;;;;cARa,cAAA;AAAA,KAQD,YAAA,WAAuB,cAAc;AAAA,KAErC,cAAA,IAAkB,KAAA,EAAO,YAAY,EAAE,IAAA;AAAA,iBAiDnC,aAAA,CAAc,OAAuB,EAAd,cAAc;;iBAYrC,0BAAA,CAAA"}

package/dist/internal/console-patch.mjs

@@ -0,0 +1 @@
+const CONSOLE_LEVELS=[`debug`,`log`,`info`,`warn`,`error`],handlers=new Set,originals={};let installed=!1;function install(){if(installed)return;installed=!0;let target=globalThis.console;for(let level of CONSOLE_LEVELS){let orig=target[level];typeof orig==`function`&&(originals[level]=orig,target[level]=(...args)=>{orig.apply(globalThis.console,args);for(let handler of handlers)handler(level,args)})}}function uninstall(){if(!installed)return;installed=!1;let target=globalThis.console;for(let level of CONSOLE_LEVELS){let orig=originals[level];orig&&(target[level]=orig,delete originals[level])}}function onConsoleCall(handler){return install(),handlers.add(handler),()=>{handlers.delete(handler),handlers.size===0&&uninstall()}}function _resetConsolePatchForTests(){handlers.clear(),uninstall()}export{CONSOLE_LEVELS,_resetConsolePatchForTests,onConsoleCall};

package/dist/internal/console-patch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-patch.mjs","names":[],"sources":["../../src/internal/console-patch.ts"],"sourcesContent":["/**\n * Single point of `console.{debug,log,info,warn,error}` patching. The\n * errors plugin and the logs plugin both want to observe console calls;\n * before this consolidation, each patched independently and the\n * resulting wrap-order coupling made teardown leaky.\n *\n * Now: a single set of patched methods is installed on first\n * subscription, fans out to every subscriber, and is uninstalled on the\n * last unsubscription. Handlers never wrap each other; they observe.\n */\nexport const CONSOLE_LEVELS = [\n  \"debug\",\n  \"log\",\n  \"info\",\n  \"warn\",\n  \"error\",\n] as const;\n\nexport type ConsoleLevel = (typeof CONSOLE_LEVELS)[number];\n\nexport type ConsoleHandler = (level: ConsoleLevel, args: unknown[]) => void;\n\nconst handlers = new Set<ConsoleHandler>();\nconst originals: Partial<Record<ConsoleLevel, (...args: unknown[]) => void>> =\n  {};\nlet installed = false;\n\nfunction install(): void {\n  if (installed) {\n    return;\n  }\n  installed = true;\n  const target = globalThis.console as unknown as Record<\n    ConsoleLevel,\n    (...args: unknown[]) => void\n  >;\n  for (const level of CONSOLE_LEVELS) {\n    const orig = target[level];\n    if (typeof orig !== \"function\") {\n      continue;\n    }\n    originals[level] = orig;\n    target[level] = (...args: unknown[]) => {\n      orig.apply(globalThis.console, args);\n      for (const handler of handlers) {\n        handler(level, args);\n      }\n    };\n  }\n}\n\nfunction uninstall(): void {\n  if (!installed) {\n    return;\n  }\n  installed = false;\n  const target = globalThis.console as unknown as Record<\n    ConsoleLevel,\n    (...args: unknown[]) => void\n  >;\n  for (const level of CONSOLE_LEVELS) {\n    const orig = originals[level];\n    if (orig) {\n      target[level] = orig;\n      delete originals[level];\n    }\n  }\n}\n\nexport function onConsoleCall(handler: ConsoleHandler): () => void {\n  install();\n  handlers.add(handler);\n  return () => {\n    handlers.delete(handler);\n    if (handlers.size === 0) {\n      uninstall();\n    }\n  };\n}\n\n/** Test hook — drops every handler and restores originals. */\nexport function _resetConsolePatchForTests(): void {\n  handlers.clear();\n  uninstall();\n}\n"],"mappings":"AAUA,MAAa,eAAiB,CAC5B,QACA,MACA,OACA,OACA,OACF,EAMM,SAAW,IAAI,IACf,UACJ,CAAC,EACH,IAAI,UAAY,GAEhB,SAAS,SAAgB,CACvB,GAAI,UACF,OAEF,UAAY,GACZ,IAAM,OAAS,WAAW,QAI1B,IAAK,IAAM,SAAS,eAAgB,CAClC,IAAM,KAAO,OAAO,OAChB,OAAO,MAAS,aAGpB,UAAU,OAAS,KACnB,OAAO,QAAU,GAAG,OAAoB,CACtC,KAAK,MAAM,WAAW,QAAS,IAAI,EACnC,IAAK,IAAM,WAAW,SACpB,QAAQ,MAAO,IAAI,CAEvB,EACF,CACF,CAEA,SAAS,WAAkB,CACzB,GAAI,CAAC,UACH,OAEF,UAAY,GACZ,IAAM,OAAS,WAAW,QAI1B,IAAK,IAAM,SAAS,eAAgB,CAClC,IAAM,KAAO,UAAU,OACnB,OACF,OAAO,OAAS,KAChB,OAAO,UAAU,OAErB,CACF,CAEA,SAAgB,cAAc,QAAqC,CAGjE,OAFA,QAAQ,EACR,SAAS,IAAI,OAAO,MACP,CACX,SAAS,OAAO,OAAO,EACnB,SAAS,OAAS,GACpB,UAAU,CAEd,CACF,CAGA,SAAgB,4BAAmC,CACjD,SAAS,MAAM,EACf,UAAU,CACZ"}

package/dist/internal/dom/actionable.d.mts

@@ -0,0 +1,27 @@
+//#region src/internal/dom/actionable.d.ts
+/**
+ * Single source of truth for "what counts as a clickable element" across
+ * the SDK. Used by both the `pages` plugin (which captures `ui_event`
+ * envelopes) and the OTel `UserInteractionInstrumentation` enrichment
+ * hook (which gates span creation + stamps target attrs). Before this
+ * was extracted, the two sites diverged and produced inconsistent
+ * notions of "actionable."
+ *
+ * `data-track-click` is the customer escape hatch — any element opted
+ * in via that attribute is treated as actionable regardless of tag/role.
+ */
+declare function isActionable(el: Element): boolean;
+declare function closestActionable(target: EventTarget | null): Element | null;
+interface ActionableDescriptor {
+  ariaLabel?: string | undefined;
+  href?: string | undefined;
+  id?: string | undefined;
+  name?: string | undefined;
+  role?: string | undefined;
+  tag: string;
+  text?: string | undefined;
+  [key: string]: unknown;
+}
+declare function describeActionable(el: Element): ActionableDescriptor;
+//#endregion
+export { ActionableDescriptor, closestActionable, describeActionable, isActionable };

package/dist/internal/dom/actionable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionable.d.mts","names":[],"sources":["../../../src/internal/dom/actionable.ts"],"mappings":";;AAkCA;;;;AAAwC;AAWxC;;;;;iBAXgB,YAAA,CAAa,EAAW,EAAP,OAAO;AAAA,iBAWxB,iBAAA,CAAkB,MAAA,EAAQ,WAAA,UAAqB,OAAO;AAAA,UAcrD,oBAAA;EACf,SAAA;EACA,IAAA;EACA,EAAA;EACA,IAAA;EACA,IAAA;EACA,GAAA;EACA,IAAA;EAAA,CACC,GAAA;AAAA;AAAA,iBAGa,kBAAA,CAAmB,EAAA,EAAI,OAAA,GAAU,oBAAoB"}

package/dist/internal/dom/actionable.mjs

@@ -0,0 +1 @@
+const ACTIONABLE_TAGS=new Set([`a`,`button`,`input`,`select`,`textarea`,`summary`,`label`]),ACTIONABLE_ROLES=new Set([`button`,`link`,`menuitem`,`tab`,`checkbox`,`radio`,`switch`]);function isActionable(el){if(ACTIONABLE_TAGS.has(el.tagName.toLowerCase()))return!0;let role=el.getAttribute(`role`);return role&&ACTIONABLE_ROLES.has(role)?!0:el.hasAttribute(`data-track-click`)}function closestActionable(target){if(!(target instanceof Element))return null;let el=target;for(;el;){if(isActionable(el))return el;el=el.parentElement}return null}function describeActionable(el){let desc={tag:el.tagName.toLowerCase()};el.id&&(desc.id=el.id);let role=el.getAttribute(`role`);role&&(desc.role=role);let name=el.getAttribute(`name`);name&&(desc.name=name);let ariaLabel=el.getAttribute(`aria-label`);ariaLabel&&(desc.ariaLabel=ariaLabel),el instanceof HTMLAnchorElement&&(desc.href=el.href);let text=el.textContent?.trim().slice(0,120);return text&&(desc.text=text),desc}export{closestActionable,describeActionable,isActionable};