@interfere/react 11.1.1 → 12.0.0

package/README.md

@@ -28,10 +28,10 @@
 
 ## Framework Guides
 
-| Framework | Package | Guide |
-| --- | --- | --- |
-| Next.js | [`@interfere/next`](https://www.npmjs.com/package/@interfere/next) | [docs/next.md](docs/next.md) |
-| Vite | [`@interfere/vite`](https://www.npmjs.com/package/@interfere/vite) + `@interfere/react` | [docs/vite.md](docs/vite.md) |
+| Framework | Package                                                                                 | Guide                        |
+| --------- | --------------------------------------------------------------------------------------- | ---------------------------- |
+| Next.js   | [`@interfere/next`](https://www.npmjs.com/package/@interfere/next)                      | [docs/next.md](docs/next.md) |
+| Vite      | [`@interfere/vite`](https://www.npmjs.com/package/@interfere/vite) + `@interfere/react` | [docs/vite.md](docs/vite.md) |
 
 ## Installation
 

package/dist/activity-BfYxFVcK.d.mts

@@ -0,0 +1,36 @@
+//#region src/internal/activity.d.ts
+declare const IDLE_AFTER_MS: number;
+declare const EXPIRE_AFTER_MS: number;
+declare const MAX_AGE_MS: number;
+declare const CHECK_INTERVAL_MS: number;
+declare const KEEPALIVE_THROTTLE_MS = 1000;
+interface ActivitySession {
+  markActivity: () => void;
+  reset: () => void;
+  /** Wall-clock epoch ms the session began; `0` when unknown. */
+  startedAt: () => number;
+}
+type SessionResumeReason = "idle" | "rotated";
+type Handler<A> = (arg: A) => void;
+declare class ActivityMonitor {
+  private session;
+  private paused;
+  private lastActivityMs;
+  private keepaliveUntilMs;
+  private checkTimer;
+  private unsubscribeShown;
+  private readonly pauseHandlers;
+  private readonly resumeHandlers;
+  onPause(handler: Handler<void>): () => void;
+  onResume(handler: Handler<SessionResumeReason>): () => void;
+  start(session: ActivitySession): void;
+  stop(): void;
+  private idleMs;
+  private isOverMaxAge;
+  private readonly poll;
+  private readonly onInput;
+  private resume;
+  private touch;
+}
+//#endregion
+export { IDLE_AFTER_MS as a, SessionResumeReason as c, EXPIRE_AFTER_MS as i, ActivitySession as n, KEEPALIVE_THROTTLE_MS as o, CHECK_INTERVAL_MS as r, MAX_AGE_MS as s, ActivityMonitor as t };

package/dist/api-wpS4xoMY.d.mts

@@ -0,0 +1,70 @@
+import { c as SessionResumeReason } from "./activity-BfYxFVcK.mjs";
+import { t as DeviceManager } from "./device-vFtWy12y.mjs";
+import { t as GeoDetector } from "./geo-PDfIZY4L.mjs";
+import { InterfereClient } from "@interfere/javascript";
+import { IdentifyParams } from "@interfere/types/sdk/identify";
+//#region src/tracking/api.d.ts
+interface SessionTrackerOptions {
+  device?: DeviceManager;
+  fetcher?: typeof globalThis.fetch;
+  geo?: GeoDetector;
+  target: InterfereClient.Options;
+}
+declare class SessionTracker {
+  private readonly client;
+  private readonly device;
+  private readonly geo;
+  private mgr;
+  private readonly activity;
+  private currentIdentity;
+  private identifiedSessionId;
+  private lastSyncedKey;
+  private inflightSyncKey;
+  private syncAttemptMs;
+  private generation;
+  private identityStarted;
+  constructor(opts: SessionTrackerOptions);
+  start(): void;
+  startDeviceIdentity(): void;
+  discardDeviceIdentity(): void;
+  private backfillIdentity;
+  onSessionPause(handler: () => void): () => void;
+  onSessionResume(handler: (reason: SessionResumeReason) => void): () => void;
+  sessionId(): (string & import("zod").$brand<"SessionId">) | null;
+  windowId(): string | null;
+  markActivity(): void;
+  getSessionStartedAt(): number;
+  getDeviceId(): string | null;
+  getFpHash(): string | null;
+  getIdentity(): {
+    avatar?: string | undefined;
+    email?: string | undefined;
+    identifier: string;
+    name?: string | undefined;
+    source: {
+      name: "Clerk";
+      type: "clerk";
+    } | {
+      name: "Auth0";
+      type: "auth0";
+    } | {
+      name: "WorkOS";
+      type: "workos";
+    } | {
+      name: string;
+      type: "custom";
+    };
+    traits?: Record<string, unknown> | undefined;
+  } | null;
+  identify(params: IdentifyParams): Promise<void>;
+  private postIdentify;
+  clearIdentity(): void;
+  reset(): void;
+  rotateSession(): void;
+  dispose(): void;
+  private ensureSynced;
+  private syncSession;
+  private onRotate;
+}
+//#endregion
+export { SessionTrackerOptions as n, SessionTracker as t };

package/dist/api.d.mts

@@ -6,11 +6,13 @@ import { Span, SpanOptions } from "@opentelemetry/api";
  * 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.
+ * Records through the kernel's private tracer provider once `init()` has
+ * run — the SDK never installs a global provider, so the global registry
+ * alone would silently produce non-recording spans. Works pre-init: the
+ * global registry's no-op tracer 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;
+export 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
@@ -19,6 +21,5 @@ declare function span<T>(name: string, fn: (span: Span) => T, options?: SpanOpti
  *
  * Safe to call before init — drops silently if no kernel is registered.
  */
-declare function capture(error: unknown): void;
-//#endregion
-export { capture, span };
+export declare function capture(error: unknown): void;
+//#endregion

package/dist/api.mjs

@@ -1 +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),error=>{let e=toError(error);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),error}):(s.end(),result)}catch(error){let e=toError(error);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),error}})}function capture(error){activeKernel()?.recordException(toException(error),{mechanism:{type:MECHANISM_TYPE.manual.capture,handled:!0}})}export{capture,span};
+import{activeKernel}from"./internal/kernel-registry.mjs";import{MECHANISM_TYPE,toError,toException}from"@interfere/types/sdk/errors";import{SpanStatusCode,trace}from"@opentelemetry/api";const TRACER_NAME=`@interfere/react`;function tracer(){return activeKernel()?.getTracer(TRACER_NAME)??trace.getTracer(TRACER_NAME)}function isPromise(value){return value!==null&&(typeof value==`object`||typeof value==`function`)&&`then`in value&&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),error=>{let e=toError(error);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),error}):(s.end(),result)}catch(error){let e=toError(error);throw s.recordException(e),s.setStatus({code:SpanStatusCode.ERROR,message:e.message}),s.end(),error}})}function capture(error){activeKernel()?.recordException(toException(error),{mechanism:{handled:!0,type:MECHANISM_TYPE.manual.capture}})}export{capture,span};

package/dist/config-Rm-ct4K1.d.mts

@@ -0,0 +1,12 @@
+import { SetRequired } from "@interfere/helpers/set-required";
+import { recordOptions } from "rrweb";
+//#region src/plugins/replay/config.d.ts
+declare const INTERFERE_MASK_TEXT_CLASS = "interfere-mask";
+declare const INTERFERE_BLOCK_CLASS = "interfere-block";
+declare const INTERFERE_IGNORE_CLASS = "interfere-ignore";
+type ReplayConfig = Pick<recordOptions<unknown>, "blockClass" | "blockSelector" | "ignoreClass" | "ignoreSelector" | "maskAllInputs" | "maskInputFn" | "maskInputOptions" | "maskTextClass" | "maskTextFn" | "maskTextSelector" | "recordCanvas">;
+type ReplayOption = boolean | ReplayConfig;
+type ReplayRecordOptions = SetRequired<ReplayConfig, "maskTextClass" | "blockClass" | "ignoreClass">;
+declare function toRecordOptions(config: ReplayConfig): ReplayRecordOptions;
+//#endregion
+export { ReplayOption as a, ReplayConfig as i, INTERFERE_IGNORE_CLASS as n, ReplayRecordOptions as o, INTERFERE_MASK_TEXT_CLASS as r, toRecordOptions as s, INTERFERE_BLOCK_CLASS as t };

package/dist/device-vFtWy12y.d.mts

@@ -0,0 +1,35 @@
+//#region src/tracking/device.d.ts
+/**
+ * Producer of an opaque, stable per-browser fingerprint hash. The default
+ * dynamic-imports the FingerprintJS OSS library and self-defers via
+ * `requestIdleCallback` so the ~1.5s of synchronous font / canvas / WebGL
+ * probing the library performs on a cold load doesn't land on the
+ * hydration tick. Tests inject a fixed-value provider that resolves
+ * immediately — they pay nothing for the production deferral.
+ */
+type FingerprintProvider = () => Promise<string | null>;
+/**
+ * Resolves on the next browser idle frame, capped at 5s. Falls back to
+ * `setTimeout(0)` (next macrotask) on hosts without
+ * `requestIdleCallback`. Exported only for the unit test that pins the
+ * "default provider gates fingerprint work via RIC" contract — not part
+ * of the package's public surface.
+ */
+declare function whenIdle(): Promise<undefined>;
+declare class DeviceManager {
+  private deviceId;
+  private fpHash;
+  private fpPending;
+  private epoch;
+  private readonly fingerprintProvider;
+  constructor(fingerprintProvider?: FingerprintProvider);
+  init(): void;
+  private startFingerprint;
+  getDeviceId(): string | null;
+  getFpHash(): string | null;
+  whenFingerprintReady(): Promise<string | null>;
+  reset(): string;
+  clear(): void;
+}
+//#endregion
+export { FingerprintProvider as n, whenIdle as r, DeviceManager as t };

package/dist/error-boundary.d.mts

@@ -1,8 +1,7 @@
-import { InterfereContext, InterfereContextValue } from "./internal/react-context.mjs";
-import "./provider.mjs";
+import { a as InterfereContextValue, i as InterfereContext } from "./provider-50LbJ4Tl.mjs";
 import { Component, ContextType, ErrorInfo, ReactNode } from "react";
 //#region src/error-boundary.d.ts
-interface ErrorBoundaryProps {
+export interface ErrorBoundaryProps {
   children: ReactNode;
   fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
   onError?: (error: Error, info: ErrorInfo) => void;
@@ -18,16 +17,17 @@ interface ErrorBoundaryState {
  *
  * Class component required — React has no hook-based error boundary API.
  */
-declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+export 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;
+  static getDerivedStateFromError(error: Error): {
+    error: Error;
+  };
   componentDidCatch(error: Error & {
     digest?: string;
   }, info: ErrorInfo): void;
   private readonly reset;
   render(): ReactNode;
 }
-//#endregion
-export { ErrorBoundary, ErrorBoundaryProps };
+//#endregion

package/dist/error-boundary.mjs

@@ -1 +1 @@
-"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};
+"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,{handled:!0,type:MECHANISM_TYPE.react.errorBoundary}),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/exporter-logs-CeGwMiMo.d.mts

@@ -0,0 +1,51 @@
+import { Attributes } from "@opentelemetry/api";
+import { InterfereClient } from "@interfere/javascript";
+import { ExportResult } from "@opentelemetry/core";
+import { AggregationTemporality, PushMetricExporter, ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { LogRecordExporter, ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
+//#region src/internal/otel/exporter-metrics.d.ts
+interface GatedResourceAttributes {
+  attributes: Attributes;
+  isEnabled: () => boolean;
+}
+declare class IngestMetricExporter implements PushMetricExporter {
+  private readonly gatedResourceAttributes;
+  private readonly send;
+  constructor(send: SignalSender, gatedResourceAttributes?: GatedResourceAttributes);
+  export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+  selectAggregationTemporality(): AggregationTemporality;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/internal/otel/exporter.d.ts
+declare const INGEST_IGNORE_RE: RegExp;
+type SignalSender = (payload: Uint8Array | undefined, resultCallback: (result: ExportResult) => void) => void;
+interface ExporterCommon {
+  clientOptions: InterfereClient.Options;
+}
+/** Test-only reset — the halt is deliberately page-lifetime state. */
+declare function resetIngestHalt(): void;
+declare function isIngestHalted(): boolean;
+declare class IngestTraceExporter implements SpanExporter {
+  private readonly send;
+  constructor(send: SignalSender);
+  export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+declare function createTraceExporter(input: ExporterCommon): IngestTraceExporter;
+declare function createMetricExporter(input: ExporterCommon, gatedResourceAttributes?: GatedResourceAttributes): IngestMetricExporter;
+declare function createLogExporter(input: ExporterCommon): IngestLogExporter;
+//#endregion
+//#region src/internal/otel/exporter-logs.d.ts
+declare class IngestLogExporter implements LogRecordExporter {
+  private readonly send;
+  constructor(send: SignalSender);
+  export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+//#endregion
+export { createMetricExporter as a, resetIngestHalt as c, createLogExporter as i, GatedResourceAttributes as l, INGEST_IGNORE_RE as n, createTraceExporter as o, SignalSender as r, isIngestHalted as s, IngestLogExporter as t, IngestMetricExporter as u };

package/dist/geo-PDfIZY4L.d.mts

@@ -0,0 +1,16 @@
+//#region src/tracking/geo.d.ts
+declare class GeoDetector {
+  private cached;
+  private pending;
+  private failed;
+  private epoch;
+  private readonly fetcher;
+  constructor(fetcher?: typeof globalThis.fetch);
+  detect(): Promise<string | null>;
+  private resolveCountryCode;
+  getCountry(): string | null;
+  clear(): void;
+  private fetchCountryCode;
+}
+//#endregion
+export { GeoDetector as t };

package/dist/index-CatPKbtv.d.mts

@@ -0,0 +1,4 @@
+import "./instrumentations-Bgm2EazU.mjs";
+import "./navigation-CkiV6lJY.mjs";
+import "./provider-Cp6noibq.mjs";
+import "./web-vitals-x8y70B5x.mjs";

package/dist/instrumentations-Bgm2EazU.d.mts

@@ -0,0 +1,91 @@
+import { Span } from "@opentelemetry/api";
+import { FetchCustomAttributeFunction } from "@opentelemetry/instrumentation-fetch";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+//#region src/internal/otel/instrumentations.d.ts
+type FetchError = Exclude<Parameters<FetchCustomAttributeFunction>[2], Response>;
+type FetchSpanRequest = Request | RequestInfo | RequestInit | URL;
+/**
+ * Inclusive HTTP status range. `[400, 499]` matches every 4xx;
+ * a bare number matches that exact code.
+ */
+type HttpStatusCodeRange = number | readonly [number, number];
+interface CaptureFailedRequestsOptions {
+  /** Defaults to `[[400, 599]]` (4xx + 5xx) when not specified. */
+  statusCodes?: readonly HttpStatusCodeRange[];
+}
+/**
+ * Promote tracked failed fetch/XHR responses to captured exception events.
+ * On by default (same-origin 4xx + 5xx, deduped + rate-limited); `false`
+ * disables, `{ statusCodes }` tunes the matched ranges.
+ */
+type CaptureFailedRequestsOption = boolean | CaptureFailedRequestsOptions;
+declare function resolveFailureRanges(opt: CaptureFailedRequestsOption | undefined): readonly HttpStatusCodeRange[] | null;
+/**
+ * Per-instrumentation gate that keeps failed-request capture low-noise:
+ * dedupes by `method+status+path` (so a flapping endpoint is captured once)
+ * and rate-limits to {@link FAILURE_RATE_MAX} captures per
+ * {@link FAILURE_RATE_WINDOW_MS} as a flood backstop. State lives in the
+ * closure — one gate per kernel instance, no module-level mutable state.
+ */
+declare function createFailureGate(): (key: string) => boolean;
+declare function classifyNetworkError(message: string): "abort" | "network" | "timeout";
+declare function applyFetchSpanAttrs(span: Span, request: FetchSpanRequest, result: Response | FetchError, failureRanges: readonly HttpStatusCodeRange[] | null, isTrackedUrl: (url: string) => boolean, resolveRoute: ((pathname: string) => string | undefined) | undefined, gate?: (key: string) => boolean): void;
+declare function applyXhrSpanAttrs(span: Span, xhr: Pick<XMLHttpRequest, "responseURL" | "status">, failureRanges: readonly HttpStatusCodeRange[] | null, isTrackedUrl: (url: string) => boolean, gate?: (key: string) => boolean, resolveRoute?: (pathname: string) => string | undefined): void;
+declare const testOnlyApplyFetchSpanAttrs: typeof applyFetchSpanAttrs;
+declare const testOnlyApplyXhrSpanAttrs: typeof applyXhrSpanAttrs;
+declare const testOnlyResolveFailureRanges: typeof resolveFailureRanges;
+declare const testOnlyCreateFailureGate: typeof createFailureGate;
+declare const testOnlyClassifyNetworkError: typeof classifyNetworkError;
+interface InstrumentationsInput {
+  /**
+   * Hostnames the fetch + XHR instrumentations inject `traceparent` onto,
+   * matched by host (any path/port/scheme). Same-origin always propagates.
+   */
+  apiHosts?: string[];
+  /** See {@link CaptureFailedRequestsOption}. On by default. */
+  captureFailedRequests?: CaptureFailedRequestsOption;
+  /**
+   * URLs the SDK exempts from `fetch` and `XHR` instrumentation —
+   * typically our own ingest/OTLP endpoints, so the SDK doesn't trace
+   * its own export requests in an infinite loop. Combined with the
+   * `THIRD_PARTY_IGNORE` defaults and the customer's `ignoreUrls`.
+   */
+  ignoreUrls: (string | RegExp)[];
+  loggerProvider?: LoggerProvider;
+  /**
+   * Customer-supplied URL patterns the fetch + XHR instrumentations
+   * inject `traceparent` + `baggage` headers on. Same-origin requests
+   * always propagate.
+   */
+  propagateContextUrls?: (string | RegExp)[];
+  /**
+   * Pathname → low-cardinality route template (e.g. `/blog/[slug]`).
+   * Drives span renaming + `url.path` / `http.route` attrs across
+   * fetch, document-load, user-interaction, and long-task.
+   */
+  resolveRoute?: (pathname: string) => string | undefined;
+  /**
+   * The kernel's private provider — instrumentations register against
+   * it, not the global one, so customer OTel setups stay untouched.
+   */
+  tracerProvider: WebTracerProvider;
+}
+interface BundledInstrumentations {
+  dispose: () => void;
+  /** Idempotent toggle for the analytics-consent-gated pageEvents signals. */
+  setPageEventsEnabled: (enabled: boolean) => void;
+}
+/**
+ * Registers the browser auto-instrumentations against the kernel's
+ * private provider. Every instrumentation is enriched with the same
+ * route-template-aware URL attributes so dashboards can slice fetch /
+ * interaction / long-task / resource-load by `http.route` without
+ * cardinality blow-up from raw pathnames.
+ */
+declare function registerBundledInstrumentations(input: InstrumentationsInput): {
+  dispose: () => void;
+  setPageEventsEnabled: (enabled: boolean) => void;
+};
+//#endregion
+export { InstrumentationsInput as a, testOnlyApplyXhrSpanAttrs as c, testOnlyResolveFailureRanges as d, HttpStatusCodeRange as i, testOnlyClassifyNetworkError as l, CaptureFailedRequestsOption as n, registerBundledInstrumentations as o, CaptureFailedRequestsOptions as r, testOnlyApplyFetchSpanAttrs as s, BundledInstrumentations as t, testOnlyCreateFailureGate as u };

package/dist/internal/activity.d.mts

@@ -1,36 +1,2 @@
-//#region src/internal/activity.d.ts
-declare const IDLE_AFTER_MS: number;
-declare const EXPIRE_AFTER_MS: number;
-declare const MAX_AGE_MS: number;
-declare const CHECK_INTERVAL_MS: number;
-declare const KEEPALIVE_THROTTLE_MS = 1000;
-interface ActivitySession {
-  markActivity: () => void;
-  reset: () => void;
-  /** Wall-clock epoch ms the session began; `0` when unknown. */
-  startedAt: () => number;
-}
-type SessionResumeReason = "idle" | "rotated";
-type Handler<A> = (arg: A) => void;
-declare class ActivityMonitor {
-  private session;
-  private paused;
-  private lastActivityMs;
-  private keepaliveUntilMs;
-  private checkTimer;
-  private unsubscribeShown;
-  private readonly pauseHandlers;
-  private readonly resumeHandlers;
-  onPause(handler: Handler<void>): () => void;
-  onResume(handler: Handler<SessionResumeReason>): () => void;
-  start(session: ActivitySession): void;
-  stop(): void;
-  private idleMs;
-  private isOverMaxAge;
-  private readonly poll;
-  private readonly onInput;
-  private resume;
-  private touch;
-}
-//#endregion
+import { a as IDLE_AFTER_MS, c as SessionResumeReason, i as EXPIRE_AFTER_MS, n as ActivitySession, o as KEEPALIVE_THROTTLE_MS, r as CHECK_INTERVAL_MS, s as MAX_AGE_MS, t as ActivityMonitor } from "../activity-BfYxFVcK.mjs";
 export { ActivityMonitor, ActivitySession, CHECK_INTERVAL_MS, EXPIRE_AFTER_MS, IDLE_AFTER_MS, KEEPALIVE_THROTTLE_MS, MAX_AGE_MS, SessionResumeReason };

package/dist/internal/activity.mjs

@@ -1 +1 @@
-import{createLogger}from"../util/log.mjs";import{onPageShown}from"./page-lifecycle.mjs";const log=createLogger(`activity`),IDLE_AFTER_MS=3e5,EXPIRE_AFTER_MS=9e5,MAX_AGE_MS=864e5,CHECK_INTERVAL_MS=3e4,KEEPALIVE_THROTTLE_MS=1e3,ACTIVITY_EVENTS=[`pointerdown`,`keydown`,`scroll`,`touchstart`,`mousemove`];function monotonicNow(){return typeof performance>`u`?Date.now():performance.now()}function subscribe(set,handler){return set.add(handler),()=>{set.delete(handler)}}function fire(handlers,arg){for(let handler of handlers)try{handler(arg)}catch(error){log.warn(`activity handler threw`,error)}}var ActivityMonitor=class{session=null;paused=!1;lastActivityMs=0;keepaliveUntilMs=0;checkTimer=null;unsubscribeShown=null;pauseHandlers=new Set;resumeHandlers=new Set;onPause(handler){return subscribe(this.pauseHandlers,handler)}onResume(handler){return subscribe(this.resumeHandlers,handler)}start(session){if(this.checkTimer===null&&typeof globalThis.addEventListener==`function`){this.session=session,this.paused=!1,this.lastActivityMs=monotonicNow(),this.keepaliveUntilMs=0;for(let type of ACTIVITY_EVENTS)globalThis.addEventListener(type,this.onInput,{capture:!0,passive:!0});this.unsubscribeShown=onPageShown(this.onInput),this.checkTimer=setInterval(this.poll,CHECK_INTERVAL_MS)}}stop(){if(this.checkTimer!==null){clearInterval(this.checkTimer),this.checkTimer=null;for(let type of ACTIVITY_EVENTS)globalThis.removeEventListener(type,this.onInput,!0);this.unsubscribeShown?.(),this.unsubscribeShown=null,this.session=null,this.paused=!1,this.lastActivityMs=0,this.keepaliveUntilMs=0}}idleMs(){return monotonicNow()-this.lastActivityMs}isOverMaxAge(){let startedAt=this.session?.startedAt()??0;return startedAt>0&&Date.now()-startedAt>=864e5}poll=()=>{this.paused||(this.isOverMaxAge()||this.idleMs()>=3e5)&&(this.paused=!0,log.debug(`session paused`),fire(this.pauseHandlers))};onInput=()=>{let now=monotonicNow();if(this.isOverMaxAge()||now-this.lastActivityMs>=9e5){this.resume(now,`rotated`);return}if(this.paused){this.resume(now,`idle`);return}now<this.keepaliveUntilMs||(this.touch(now),this.session?.markActivity())};resume(now,reason){reason===`rotated`&&(log.debug(`resume after expiry → new session`),this.session?.reset()),this.paused=!1,this.touch(now),this.session?.markActivity(),fire(this.resumeHandlers,reason)}touch(now){this.lastActivityMs=now,this.keepaliveUntilMs=now+KEEPALIVE_THROTTLE_MS}};export{ActivityMonitor,CHECK_INTERVAL_MS,EXPIRE_AFTER_MS,IDLE_AFTER_MS,KEEPALIVE_THROTTLE_MS,MAX_AGE_MS};
+import{createLogger}from"../util/log.mjs";import{onPageShown}from"./page-lifecycle.mjs";const log=createLogger(`activity`),IDLE_AFTER_MS=3e5,EXPIRE_AFTER_MS=9e5,MAX_AGE_MS=864e5,CHECK_INTERVAL_MS=3e4,KEEPALIVE_THROTTLE_MS=1e3,ACTIVITY_EVENTS=[`pointerdown`,`keydown`,`scroll`,`touchstart`,`mousemove`];function monotonicNow(){return typeof performance>`u`?Date.now():performance.now()}function subscribe(set,handler){return set.add(handler),(()=>{set.delete(handler)})}function fire(handlers,arg){for(let handler of handlers)try{handler(arg)}catch(error){log.warn(`activity handler threw: %s`,error instanceof Error?error.constructor.name:`UnknownError`)}}var ActivityMonitor=class{session=null;paused=!1;lastActivityMs=0;keepaliveUntilMs=0;checkTimer=null;unsubscribeShown=null;pauseHandlers=new Set;resumeHandlers=new Set;onPause(handler){return subscribe(this.pauseHandlers,handler)}onResume(handler){return subscribe(this.resumeHandlers,handler)}start(session){if(this.checkTimer===null&&typeof globalThis.addEventListener==`function`){this.session=session,this.paused=!1,this.lastActivityMs=monotonicNow(),this.keepaliveUntilMs=0;for(let type of ACTIVITY_EVENTS)globalThis.addEventListener(type,this.onInput,{capture:!0,passive:!0});this.unsubscribeShown=onPageShown(this.onInput),this.checkTimer=setInterval(this.poll,CHECK_INTERVAL_MS)}}stop(){if(this.checkTimer!==null){clearInterval(this.checkTimer),this.checkTimer=null;for(let type of ACTIVITY_EVENTS)globalThis.removeEventListener(type,this.onInput,!0);this.unsubscribeShown?.(),this.unsubscribeShown=null,this.session=null,this.paused=!1,this.lastActivityMs=0,this.keepaliveUntilMs=0}}idleMs(){return monotonicNow()-this.lastActivityMs}isOverMaxAge(){let startedAt=this.session?.startedAt()??0;return startedAt>0&&Date.now()-startedAt>=864e5}poll=()=>{this.paused||(this.isOverMaxAge()||this.idleMs()>=3e5)&&(this.paused=!0,log.debug(`session paused`),fire(this.pauseHandlers,void 0))};onInput=()=>{let now=monotonicNow();if(this.isOverMaxAge()||now-this.lastActivityMs>=9e5){this.resume(now,`rotated`);return}if(this.paused){this.resume(now,`idle`);return}now<this.keepaliveUntilMs||(this.touch(now),this.session?.markActivity())};resume(now,reason){reason===`rotated`&&(log.debug(`resume after expiry → new session`),this.session?.reset()),this.paused=!1,this.touch(now),this.session?.markActivity(),fire(this.resumeHandlers,reason)}touch(now){this.lastActivityMs=now,this.keepaliveUntilMs=now+KEEPALIVE_THROTTLE_MS}};export{ActivityMonitor,CHECK_INTERVAL_MS,EXPIRE_AFTER_MS,IDLE_AFTER_MS,KEEPALIVE_THROTTLE_MS,MAX_AGE_MS};

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

@@ -1,5 +1,45 @@
-import { BrowserContext } from "@interfere/types/sdk/plugins/context/browser";
 //#region src/internal/browser-context.d.ts
-declare function collectContext(): Promise<BrowserContext>;
-//#endregion
-export { collectContext };
+export declare function collectContext(): Promise<{
+  browser: {
+    display: {
+      screen: {
+        height: number;
+        orientation: OrientationType;
+        width: number;
+      };
+    };
+    language: string;
+    timezone: string;
+  } | null;
+  device: {
+    browser: {
+      fullVersion?: string | undefined;
+      major?: string | undefined;
+      name?: string | undefined;
+      type?: string | undefined;
+      version?: string | undefined;
+    };
+    cpu: {
+      architecture?: string | undefined;
+      bitness?: string | undefined;
+    };
+    device: {
+      model?: string | undefined;
+      type?: string | undefined;
+      vendor?: string | undefined;
+    };
+    engine: {
+      name?: string | undefined;
+      version?: string | undefined;
+    };
+    frozenUa?: boolean | undefined;
+    os: {
+      name?: string | undefined;
+      version?: string | undefined;
+      versionFull?: string | undefined;
+    };
+    ua: string;
+  } | null;
+  runtime: "browser";
+}>;
+//#endregion

package/dist/internal/browser-context.mjs

@@ -1 +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/iu,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};
+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/iu,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==null)return null;let fullVersion=hints.fullVersionList?.find(b=>!NOT_A_BRAND_REGEX.test(b.brand))?.version,metadata={...parsed,browser:{...parsed.browser},cpu:{...parsed.cpu},frozenUa:isFrozenUA(navigator.userAgent),os:{...parsed.os}};return fullVersion&&(metadata.browser.fullVersion=fullVersion),hints.bitness&&(metadata.cpu.bitness=hints.bitness),hints.platformVersion&&(metadata.os.versionFull=hints.platformVersion),metadata}function getBrowserMetadata(){if([typeof navigator,typeof screen,typeof globalThis].some(x=>x===`undefined`))return null;let{language}=navigator;return{display:{screen:{height:screen.availHeight,orientation:screen.orientation?.type,width:screen.availWidth}},language,timezone:Intl.DateTimeFormat().resolvedOptions().timeZone}}async function collectContext(){return{browser:getBrowserMetadata(),device:await getDeviceMetadata(),runtime:`browser`}}export{collectContext};

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

@@ -1,4 +1,4 @@
-import { InterfereContext, InterfereContextValue } from "./react-context.mjs";
+import { a as InterfereContextValue, i as InterfereContext } from "../provider-50LbJ4Tl.mjs";
 import { Component, ContextType, ReactNode } from "react";
 //#region src/internal/capture-boundary.d.ts
 interface CaptureBoundaryProps {
@@ -30,12 +30,13 @@ interface CaptureBoundaryState {
  * `mechanism.handled` is `false` because from Interfere's perspective we
  * captured the error but did not render a fallback — propagation continues.
  */
-declare class CaptureBoundary extends Component<CaptureBoundaryProps, CaptureBoundaryState> {
+export 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;
+  static getDerivedStateFromError(error: Error): {
+    error: Error;
+  };
   render(): ReactNode;
 }
-//#endregion
-export { CaptureBoundary };
+//#endregion

package/dist/internal/capture-boundary.mjs

@@ -1 +1 @@
-"use client";import{captureReactError}from"./capture.mjs";import{InterfereContext}from"./react-context.mjs";import{hasServerDigest}from"./server-digest.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 hasServerDigest(this.state.error)||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};
+"use client";import{captureReactError}from"./capture.mjs";import{InterfereContext}from"./react-context.mjs";import{hasServerDigest}from"./server-digest.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 hasServerDigest(this.state.error)||captureReactError(this.context?.kernel??null,this.state.error,null,{handled:!1,type:MECHANISM_TYPE.react.captureBoundary}),this.state.error;return this.props.children}};export{CaptureBoundary};

package/dist/internal/capture.d.mts

@@ -1,4 +1,4 @@
-import { Kernel } from "./kernel.mjs";
+import { s as Kernel } from "../provider-50LbJ4Tl.mjs";
 import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
 //#region src/internal/capture.d.ts
 /**
@@ -16,8 +16,7 @@ import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
  * `<InterfereProvider>` tree, in which case we silently skip capture and
  * let the host render its fallback / call its `onError` callback.
  */
-declare function captureReactError(kernel: Kernel | null, error: Error & {
+export declare function captureReactError(kernel: Pick<Kernel, "recordException"> | null, error: Error & {
   digest?: string;
 }, componentStack: string | null | undefined, mechanism: ErrorMechanism): void;
-//#endregion
-export { captureReactError };
+//#endregion

package/dist/internal/capture.mjs

@@ -1 +1 @@
-import{isHydrationError}from"./hydration.mjs";import{parseReactComponentStack}from"@interfere/types/sdk/errors";function captureReactError(kernel,error,componentStack,mechanism){if(!kernel)return;let hydration=isHydrationError(error);kernel.recordException(error,{mechanism:hydration?{...mechanism,synthetic:!1}:mechanism,...hydration?{subtype:`hydration`}:{},...componentStack?{appendFrames:parseReactComponentStack(componentStack)}:{},...error.digest?{errorDigest:error.digest}:{}})}export{captureReactError};
+import{isHydrationError}from"./hydration.mjs";import{parseReactComponentStack}from"@interfere/types/sdk/errors";import{omitUndefined}from"@interfere/helpers/omit-undefined";function captureReactError(kernel,error,componentStack,mechanism){if(!kernel)return;let hydration=isHydrationError(error);kernel.recordException(error,omitUndefined({mechanism:hydration?{...mechanism,synthetic:!1}:mechanism,subtype:hydration?`hydration`:void 0,appendFrames:componentStack?parseReactComponentStack(componentStack):void 0,errorDigest:error.digest||void 0}))}export{captureReactError};

package/dist/internal/config.d.mts

@@ -1,29 +1,28 @@
 //#region src/internal/config.d.ts
-interface IngestTarget {
-  headers: Headers;
-  url: string;
-}
-interface AuthHeaders {
-  headers: Headers;
-}
-declare function setIngestHost(host: string): void;
-declare function withQueryParam(url: string, key: string, value: string): string;
-declare function appendPathBeforeQuery(url: string, path: string): string;
-declare function resolveTargets(apiHost?: string, ingestHost?: string): {
-  /**
-   * 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;
-  /**
-   * 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;
+/**
+ * Force enable is the explicit opt-in for telemetry outside production. It
+ * also overrides the bot gate, so a browser under test can start a kernel.
+ */
+export declare function isForceEnableActive(): boolean;
+export declare function setIngestHost(host: string): void;
+export declare function resolveTargets(apiHost?: string, ingestHost?: string): {
+  config: {
+    headers: Record<string, string>;
+    publicKeyHeader: {
+      apiKey: string;
+    } | undefined;
+    timeoutInSeconds: number;
+    maxRetries: number;
+    baseUrl: string;
+  };
+  ingest: {
+    headers: Record<string, string>;
+    publicKeyHeader: {
+      apiKey: string;
+    } | undefined;
+    timeoutInSeconds: number;
+    maxRetries: number;
+    baseUrl: string;
+  };
 };
-//#endregion
-export { AuthHeaders, IngestTarget, appendPathBeforeQuery, resolveTargets, setIngestHost, withQueryParam };
+//#endregion