@interfere/react 11.1.1 → 12.0.0

package/dist/provider-50LbJ4Tl.d.mts

@@ -0,0 +1,466 @@
+import { c as SessionResumeReason } from "./activity-BfYxFVcK.mjs";
+import { a as ReplayOption, i as ReplayConfig } from "./config-Rm-ct4K1.mjs";
+import { t as SessionTracker } from "./api-wpS4xoMY.mjs";
+import { n as CaptureFailedRequestsOption, t as BundledInstrumentations } from "./instrumentations-Bgm2EazU.mjs";
+import { t as OtelProviderHandle } from "./provider-Cp6noibq.mjs";
+import "./index-CatPKbtv.mjs";
+import { NonErrorException } from "@interfere/types/sdk/errors";
+import { Tracer } from "@opentelemetry/api";
+import { PropsWithChildren } from "react";
+import { ConsentState, PluginKey } from "@interfere/types/sdk/plugins/manifest";
+import { RemotePluginConfig } from "@interfere/types/sdk/remote-config";
+import { SessionId } from "@interfere/types/data/session";
+import { MetricReader } from "@opentelemetry/sdk-metrics";
+import { LogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { IngestedFrame } from "@interfere/types/data/frame";
+import { IdentifyParams } from "@interfere/types/sdk/identify";
+import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
+//#region src/plugins/lib/types.d.ts
+type PluginTeardownReason = "consent-revoked" | "disabled" | "dispose";
+type PluginCleanup = (reason?: PluginTeardownReason) => void;
+type PluginConfigState = "disabled" | "enabled" | "pending";
+interface PluginContext {
+  getPluginConfigState: (key: PluginKey) => PluginConfigState;
+  getReplayConfig: () => ReplayConfig;
+  getSessionId: () => string;
+  getTracer: (name: string) => Tracer;
+  getWindowId: () => string;
+  onSessionPause: (handler: () => void) => () => void;
+  onSessionResume: (handler: (reason: SessionResumeReason) => void) => () => void;
+  recordException: (value: Error | NonErrorException, opts: RecordExceptionOpts) => void;
+  startDeviceInfoCapture: () => PluginCleanup | null;
+  startPageEventsCapture: () => PluginCleanup | null;
+  subscribePluginConfigState: (key: PluginKey, listener: (state: PluginConfigState) => void) => () => void;
+}
+interface Plugin {
+  readonly name: string;
+  setup: (ctx: PluginContext) => PluginCleanup | undefined;
+}
+//#endregion
+//#region src/plugins/lib/loader.d.ts
+type PluginLoader = () => Promise<{
+  default: Plugin;
+} | Plugin> | Plugin;
+declare const LOADERS: Record<PluginKey, PluginLoader>;
+type PluginOverrides = Partial<Record<Exclude<PluginKey, "replay">, boolean>> & {
+  replay?: ReplayOption;
+};
+declare function resolveFeatures(overrides?: PluginOverrides): {
+  device: boolean;
+  errors: boolean;
+  logs: boolean;
+  pageEvents: boolean;
+  rageClick: boolean;
+  replay: boolean;
+};
+declare function loadPlugin(key: PluginKey, context: PluginContext): Promise<PluginCleanup | null>;
+//#endregion
+//#region src/internal/plugin-runtime.d.ts
+declare class PluginRuntime {
+  private readonly activeCleanups;
+  private readonly pending;
+  private features;
+  private readonly pluginConfigListeners;
+  private remoteConfig;
+  private remoteConfigSettled;
+  private consentState;
+  private configSettled;
+  private replayConfig;
+  private syncVersion;
+  private disposed;
+  private readonly context;
+  private readonly hasInitialConsent;
+  constructor(context: PluginContext, consent?: ConsentState, remoteConfig?: RemotePluginConfig);
+  getConsent(): ConsentState | null;
+  getReplayConfig(): ReplayConfig;
+  applyProviderConfig(overrides: PluginOverrides | undefined, consent: ConsentState | undefined): void;
+  setConsent(nextConsent?: ConsentState): void;
+  resetConsent(): void;
+  applyRemoteConfig(config: RemotePluginConfig): void;
+  applyRemoteConfigDefaults(): void;
+  start(): void;
+  dispose(): Promise<void>;
+  private shouldEnablePlugin;
+  getPluginConfigState(key: PluginKey): "disabled" | "enabled" | "pending";
+  subscribePluginConfigState(key: PluginKey, listener: (state: PluginConfigState) => void): () => void;
+  private emitPluginConfigState;
+  private teardownReason;
+  private deactivate;
+  private activate;
+  private sync;
+}
+//#endregion
+//#region src/internal/kernel.d.ts
+declare function buildSdkStack(wrapperVersions?: string[]): string[];
+interface KernelOptions {
+  /** Saved consent applied before device identity and tracing start. */
+  consent?: ConsentState | undefined;
+  /**
+   * The endpoint the SDK posts telemetry to. Defaults to Interfere's
+   * endpoint. Set it to a subdomain of your own site that resolves to
+   * Interfere via a DNS record (e.g. `"https://in.example.com"`) to
+   * survive ad-blockers, or to a regional endpoint. Must be a full URL.
+   */
+  apiHost?: string;
+  /**
+   * Override the automatic dev-mode guard. When `undefined`, the SDK
+   * auto-detects: it disables itself if `process.env["NODE_ENV"]` is not
+   * `"production"` (Node / webpack / Next.js). In environments where
+   * `process` does not exist (Vite, CRA, plain browser) the SDK
+   * defaults to **enabled** — pass `false` to disable explicitly.
+   */
+  enabled?: boolean;
+  /** Override `globalThis.fetch` for tests / non-browser hosts. */
+  fetch?: typeof globalThis.fetch;
+  /**
+   * Override the OTel `service.name` resource attribute. Defaults to
+   * `"interfere-sdk"`. Customers running multiple frontends in one
+   * monitoring backend (e.g. `"@interfere/website"` vs
+   * `"@interfere/app"`) set this so spans/metrics/logs slice
+   * cleanly by surface.
+   */
+  serviceName?: string;
+  /**
+   * `false` skips the OTel module entirely — the bundler code-splits
+   * `internal/otel/*` out of this path so the error-only bundle never
+   * imports the OTel SDK. `true` (default) loads it with default
+   * instrumentation config. An object loads it with the supplied
+   * config.
+   */
+  tracing?: boolean | TracingOptions;
+}
+/**
+ * Per-instrumentation tuning. Every field is optional; defaults match
+ * what `interfere/homepage` and `interfere/dashboard` use today via
+ * the internal `observability/browser/rum.ts`. New customers don't
+ * need to touch any of these — sensible defaults ship out of the box.
+ */
+interface TracingOptions {
+  /**
+   * Hostnames where your backend runs, e.g. `["api.example.com"]`. Every
+   * request to a listed host carries the W3C `traceparent` header so the
+   * browser trace continues on the server. Same-origin requests always
+   * propagate — you only need this when your API is on a different host
+   * than your app. Matched by hostname (any path, port, or scheme); no regex.
+   */
+  apiHosts?: string[];
+  /**
+   * Promote failed `fetch` / `XHR` responses to exception events on the
+   * active span. **On by default** — captures same-origin (and
+   * `propagateContextUrls`) 4xx + 5xx, deduped by `method+status+path` and
+   * rate-limited so a flapping endpoint can't flood. Pass `false` to
+   * disable, or `{ statusCodes }` to tune the ranges.
+   * See {@link CaptureFailedRequestsOption}.
+   */
+  captureFailedRequests?: CaptureFailedRequestsOption;
+  /**
+   * Additional URL patterns to skip when creating fetch / XHR spans.
+   * The SDK's own collector endpoint is always ignored; customer-side
+   * third-party SDKs (Clerk, Sentry, GTM, etc.) are also skipped by
+   * default — supplement with anything specific to your app.
+   */
+  ignoreUrls?: (string | RegExp)[];
+  /**
+   * @deprecated Prefer {@link apiHosts} — it takes plain hostnames and
+   * needs no regex. Still fully supported: raw URL patterns injected with
+   * `traceparent` + `baggage` on outgoing fetch / XHR. Note string entries
+   * match the full request URL by exact equality (an OpenTelemetry quirk),
+   * so cross-origin values usually have to be a `RegExp`.
+   */
+  propagateContextUrls?: (string | RegExp)[];
+  /**
+   * Resolve a URL pathname to a low-cardinality route template
+   * (e.g. `/blog/[slug]`). Without this, dynamic routes produce one
+   * unique span / metric label per visited slug — a cardinality
+   * hazard. Used by fetch, document-load resource enrichment,
+   * user-interaction, long-task, and web-vitals.
+   */
+  resolveRoute?: (pathname: string) => string | undefined;
+  /**
+   * `false` disables Core Web Vitals capture (LCP/FCP/TTFB/INP/CLS).
+   * Defaults to enabled; customers who run their own vitals reporting
+   * can opt out.
+   */
+  webVitals?: boolean;
+}
+/**
+ * Framework wrappers (`@interfere/next`, `@interfere/vite`) pass extra
+ * fields through `createKernel` that customers never set themselves.
+ * Kept off the customer-facing `KernelOptions` to make the public surface
+ * clean.
+ *
+ * @internal
+ */
+interface KernelInternalOptions extends KernelOptions {
+  /** @internal */
+  _internalAdditionalLogRecordProcessors?: LogRecordProcessor[];
+  /** @internal */
+  _internalAdditionalMetricReaders?: MetricReader[];
+  /** @internal */
+  _internalAdditionalSpanProcessors?: SpanProcessor[];
+  /** Wrapper SDK versions (e.g. `@interfere/next@10.0.0`). */
+  _wrapperVersions?: string[];
+}
+interface KernelConsent {
+  get: () => ConsentState | null;
+  set: (value?: ConsentState) => void;
+}
+interface KernelIdentity {
+  clear: () => void;
+  get: () => IdentifyParams | null;
+  set: (params: IdentifyParams) => Promise<void>;
+}
+interface KernelDevice {
+  getDeviceId: () => string | null;
+  getFpHash: () => string | null;
+}
+interface KernelSession {
+  getId: () => SessionId | null;
+  getWindowId: () => string | null;
+}
+interface RecordExceptionOpts {
+  /**
+   * Frames always appended to the first exception's stack. Used by
+   * `<ErrorBoundary>` to inject React's component-stack frames as
+   * supplementary context — these add on top of the real JS frames, they
+   * don't replace them.
+   */
+  readonly appendFrames?: readonly IngestedFrame[];
+  /**
+   * `error.digest` from React when an RSC server-side throw is
+   * sanitised and rebuilt as a synthetic Error on the client. The only
+   * identifier that pairs the redacted client capture with the
+   * unredacted server capture — enrichment mixes this into the
+   * fingerprint so both events group as one problem.
+   */
+  readonly errorDigest?: string;
+  /**
+   * Frames adopted only when the first exception's parsed stack is empty.
+   * Used by the `window.onerror` handler when the browser hands us
+   * source/line/col but the `Error` itself has a degenerate stack — never
+   * glued on top of a real stack.
+   */
+  readonly fallbackFrames?: readonly IngestedFrame[];
+  readonly mechanism: ErrorMechanism;
+  /**
+   * A distinct error sub-classification layered on top of the mechanism —
+   * currently `"hydration"` for React hydration mismatches. Lets Interfere
+   * triage by kind without re-parsing the message.
+   */
+  readonly subtype?: string;
+}
+/**
+ * The replacement for the old `Client` god-object. Pure construction graph
+ * via `createKernel`; no module-level mutable state, no global lookups.
+ * Framework wrappers (`@interfere/next`, `@interfere/vite`) own the
+ * singleton lifecycle.
+ *
+ * Implements `PluginContext` directly: plugins are wired with the kernel
+ * itself rather than a closure adapter. The kernel⇄runtime cycle is
+ * resolved by constructing the kernel first and binding the runtime via
+ * `attachRuntime` immediately after.
+ */
+declare class Kernel implements PluginContext {
+  readonly consent: KernelConsent;
+  readonly identity: KernelIdentity;
+  readonly device: KernelDevice;
+  readonly session: KernelSession;
+  private readonly seen;
+  private readonly initialNavigationSeen;
+  private runtime;
+  private otel;
+  private otelDispose;
+  private otelControls;
+  private deviceInfoCaptureEnabled;
+  private unsubscribePageHidden;
+  private readonly tracker;
+  constructor(tracker: SessionTracker);
+  /**
+   * Bound by `createKernel` immediately after construction.
+   *
+   * @internal
+   */
+  attachRuntime(runtime: PluginRuntime): void;
+  private requireRuntime;
+  /** PluginContext shim: plugins expect a non-null string. */
+  getSessionId(): "" | (string & import("zod").$brand<"SessionId">);
+  getWindowId(): string;
+  onSessionPause(handler: () => void): () => void;
+  onSessionResume(handler: (reason: SessionResumeReason) => void): () => void;
+  getPluginConfigState(key: PluginKey): "disabled" | "enabled" | "pending";
+  getReplayConfig(): ReplayConfig;
+  subscribePluginConfigState(key: PluginKey, listener: (state: PluginConfigState) => void): () => void;
+  getTracer(name: string): import("@opentelemetry/api").Tracer;
+  startPageEventsCapture(): (() => void) | null;
+  startDeviceInfoCapture(): (reason: PluginTeardownReason | undefined) => void;
+  isDeviceInfoCaptureEnabled(): boolean;
+  /**
+   * Records an exception event on the active OTel span. No envelope
+   * path — the SDK is OTel-only. Single dedup boundary: drops repeats
+   * of the same `Error` instance, plus browser-extension noise and
+   * unresolvable stacks. Upstream callers (the errors plugin's
+   * `window.onerror` / `console.error` / `unhandledrejection`, the
+   * React error boundary) just call this — they don't pre-filter.
+   *
+   * Does NOT mark the active span as failed. A console.error inside a
+   * customer-owned `span()` block would otherwise taint the customer's
+   * span even when the customer caught the error explicitly. The
+   * customer's `span()` helper sets status itself when it observes a
+   * throw.
+   *
+   * `appendFrames` are always appended (component-stack supplements);
+   * `fallbackFrames` are only adopted when the parsed stack is empty
+   * (`window.onerror` source/line/col when the Error has no usable
+   * stack). Both ride on the serialised `interfere.exception.chain`
+   * attribute when the chain is non-trivial.
+   */
+  recordException(value: Error | NonErrorException, opts: RecordExceptionOpts): void;
+  /**
+   * Emits an OTel `LogRecord` via the kernel's logger provider. Used by
+   * `plugins/logs.ts` to capture string-only `console.*` calls (the
+   * errors plugin still owns Error-bearing console calls — class
+   * boundary). No-ops when OTel is not wired (`tracing: false`) since
+   * there's no logger provider to emit through.
+   */
+  recordLog(input: {
+    severityText: string;
+    severityNumber: number;
+    body: string;
+    attributes?: Record<string, string>;
+  }): void;
+  recordInitialNavigation(loggerProvider: LoggerProvider): void;
+  /**
+   * Force-flushes the OTel exporters. Returns once they've settled
+   * (success or failure) so callers driving unload — page-lifecycle
+   * handlers, integration test teardown — can actually await
+   * completion. The OTel SDK swallows export errors internally; we
+   * surface the resolution either way.
+   */
+  flush(): Promise<void>;
+  /**
+   * Wired by `createKernel` after the OTel module has been
+   * lazy-loaded. Held on the kernel so `flush()` and `dispose()` can fan
+   * out to the providers. The tracer/meter providers stay private —
+   * customers don't get raw OTel access; the public surface is the
+   * `span()` / `capture()` helpers in `api.ts`.
+   *
+   * @internal
+   */
+  attachOtel(handle: OtelProviderHandle, dispose: () => void, controls?: Pick<BundledInstrumentations, "setPageEventsEnabled">): void;
+  syncProviderConfig(config: {
+    consent?: ConsentState | undefined;
+    plugins?: PluginOverrides | undefined;
+  }): void;
+  dispose(): Promise<void>;
+}
+interface CreateKernelInput {
+  opts?: KernelInternalOptions;
+}
+declare function createKernel(input?: CreateKernelInput): Promise<Kernel>;
+declare function isEnabledByEnvironment(): boolean;
+/**
+ * Build-time-derived release slug. The build step
+ * (`@interfere/next/withInterfere`, `@interfere/vite/plugin`) takes the
+ * leading 16 hex chars of the commit SHA (`rel_<16hex>`) and stamps it into
+ * the bundle as `__INTERFERE_RELEASE_SLUG__`. The collector derives the same
+ * value from the create-release request, so the bundle's runtime slug is
+ * guaranteed to match the row without a round-trip.
+ *
+ * Returns `null` when no slug was injected (dev builds, customers who
+ * haven't wired up the plugin).
+ */
+declare function readReleaseSlugFromGlobals(): (`rel_${string}` & import("zod").$brand<"ReleaseSlug">) | null;
+//#endregion
+//#region src/internal/react-context.d.ts
+interface InterfereContextValue {
+  consent: {
+    get: () => ConsentState | null;
+    set: (state?: ConsentState) => void;
+  };
+  device: {
+    getDeviceId: () => string | null;
+    getFpHash: () => string | null;
+  };
+  identity: {
+    clear: () => void;
+    get: () => IdentifyParams | null;
+    set: (params: IdentifyParams) => Promise<void>;
+  };
+  /**
+   * The active kernel, or `null` when the SDK isn't initialized yet — for
+   * example during server-side prerender, when `init()` is client-only.
+   * Accessor objects (consent/device/identity/session) above stay safe to
+   * call in either state; they no-op when the kernel is null.
+   */
+  kernel: Kernel | null;
+  session: {
+    getId: () => string | null;
+    getWindowId: () => string | null;
+  };
+}
+/**
+ * Context value used when the provider is mounted without a kernel — every
+ * accessor returns `null` and mutations are no-ops. Lets `useInterfere()`
+ * work seamlessly across SSR/CSR boundaries (server gets nulls, client
+ * gets real values once the kernel resolves).
+ */
+declare const NULL_CONTEXT_VALUE: InterfereContextValue;
+/**
+ * Lives in its own module so `provider.tsx` and `internal/capture-boundary.tsx`
+ * can both import it without forming an import cycle.
+ */
+declare const InterfereContext: import("react").Context<InterfereContextValue | null>;
+//#endregion
+//#region src/provider.d.ts
+interface InterfereProviderProps extends PropsWithChildren {
+  /**
+   * Consent state gating which plugin categories may run. Omit (or pass
+   * `undefined`) to preserve consent supplied to `init()`. Without initial
+   * consent, omitting this prop leaves every category allowed.
+   */
+  consent?: ConsentState | undefined;
+  /**
+   * Auto-install an internal capture boundary around `children` so
+   * render-phase React errors are reported even when the host app has no
+   * `ErrorBoundary` / `error.tsx` of its own.
+   *
+   * The internal boundary is transparent: it captures the error and then
+   * re-throws so upstream boundaries (the customer's own, Next.js's
+   * `error.tsx` / `global-error.tsx`, or React's default unmount) keep full
+   * control of what the user sees. Safe to leave enabled.
+   *
+   * Pass `false` only if you explicitly don't want automatic capture of
+   * render-phase errors — for example, if you've already wired
+   * {@link reactErrorHandler} into `createRoot()`.
+   *
+   * @default true
+   */
+  errorBoundary?: boolean;
+  /**
+   * The active kernel from `init()`. Pass `null` (or omit on the server)
+   * when the SDK isn't initialized — useful during SSR/SSG where `init()`
+   * runs client-side only. The provider mounts with null-safe accessors
+   * and switches to the real kernel once it's available.
+   */
+  kernel: Kernel | null;
+  /**
+   * Per-plugin overrides, merged over the manifest defaults. Generic plugins
+   * are booleans (e.g. `{ pageEvents: false }`). `replay` additionally accepts
+   * a config object — `{ replay: { maskAllInputs: true } }` enables replay
+   * with that masking config; `{ replay: false }` disables it. Privacy classes
+   * are always applied, regardless of config: `interfere-block` elements are
+   * dropped and replay as a same-size placeholder, `interfere-mask` masks the
+   * text of an element and all its children, and `interfere-ignore` stops an
+   * element's input events from being recorded. `input[type="password"]` is
+   * masked by default; use `maskInputOptions`/`maskAllInputs` to mask other
+   * input values. `init()` no longer accepts plugin config; this is the only
+   * place it lives.
+   */
+  plugins?: PluginOverrides | undefined;
+}
+declare function InterfereProvider({ kernel, children, consent, plugins, errorBoundary }: InterfereProviderProps): import("react").JSX.Element;
+declare function useInterfere(): InterfereContextValue;
+declare function useSession(): string | null;
+//#endregion
+export { loadPlugin as C, PluginConfigState as D, PluginCleanup as E, PluginContext as O, PluginOverrides as S, Plugin as T, createKernel as _, InterfereContextValue as a, PluginRuntime as b, KernelConsent as c, KernelInternalOptions as d, KernelOptions as f, buildSdkStack as g, TracingOptions as h, InterfereContext as i, PluginTeardownReason as k, KernelDevice as l, RecordExceptionOpts as m, useInterfere as n, NULL_CONTEXT_VALUE as o, KernelSession as p, useSession as r, Kernel as s, InterfereProvider as t, KernelIdentity as u, isEnabledByEnvironment as v, resolveFeatures as w, LOADERS as x, readReleaseSlugFromGlobals as y };

package/dist/provider-Cp6noibq.d.mts

@@ -0,0 +1,101 @@
+import { t as PageScopeContextManager } from "./page-scope-context-manager-r92ZMJok.mjs";
+import { InterfereClient } from "@interfere/javascript";
+import { ReleaseSlug } from "@interfere/types/releases/slug";
+import { SessionId } from "@interfere/types/data/session";
+import { MeterProvider, MetricReader, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { LogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+//#region src/internal/otel/provider.d.ts
+interface OtelProviderInput {
+  /** @internal */
+  additionalLogRecordProcessors?: LogRecordProcessor[];
+  /** @internal */
+  additionalMetricReaders?: MetricReader[];
+  /** @internal */
+  additionalSpanProcessors?: SpanProcessor[];
+  /**
+   * Auth + content headers for OTLP exports. Sourced from the kernel's
+   * already-resolved ingest target so the OTLP path inherits the same
+   * transport metadata the rest of the SDK uses — no separate auth knob.
+   */
+  clientOptions: InterfereClient.Options;
+  /**
+   * Returns the current `DeviceManager` device id. Wired into per-span
+   * and per-log processors so a mid-page device rotation
+   * (`identity.clear()` after logout) lands on subsequent spans / logs
+   * without the kernel rebuilding the providers. Returns `null` before
+   * the device manager has bootstrapped, or in SSR / test boot paths.
+   *
+   * Not applied to metrics: the MeterProvider takes a static resource
+   * and rebuilding it mid-page would destroy the periodic reader; metrics
+   * remain stamped with the boot-time device id.
+   */
+  getDeviceId: () => string | null;
+  /**
+   * Returns the kernel's current session id. Wired into per-span /
+   * per-log session processors so a mid-page session rotation (30-min
+   * idle expiry, manual reset) lands on subsequent spans without the
+   * kernel having to rebuild the providers. Returns `null` before the
+   * `SessionTracker` has bootstrapped.
+   */
+  getSessionId: () => SessionId | null;
+  /**
+   * Consent gate for the browser-detector attributes (`browser.*`,
+   * `user_agent.original`), read per span / log / metric export so a
+   * mid-page consent change needs no provider rebuild. Defaults to deny;
+   * the kernel wires it to the `device` plugin's activation state.
+   */
+  isDeviceInfoEnabled?: () => boolean;
+  /** Optional release slug — top-level `release.slug` attr (Phase 6 wire identity). */
+  releaseSlug?: ReleaseSlug | null | undefined;
+  /**
+   * Producer chain for the `interfere.sdk.stack` resource attribute —
+   * e.g. `["@interfere/next@10.0.0", "@interfere/react@10.0.0"]`.
+   * Wrapper-injected; the kernel just forwards.
+   */
+  sdkStack: string[];
+  /**
+   * Override the OTel `service.name` resource attribute. Defaults to
+   * `"interfere-sdk"`.
+   */
+  serviceName?: string;
+}
+interface OtelProviderHandle {
+  /**
+   * Page-scope context manager. The kernel calls `setPageScope(ctx)` after
+   * extracting the SSR `traceparent` meta tag so spans without a more
+   * specific zone descend from the server-side parent.
+   */
+  contextManager: PageScopeContextManager;
+  /** Force-flush all three providers — call from kernel.flush() / on visibility hidden. */
+  flush: () => Promise<void>;
+  loggerProvider: LoggerProvider;
+  meterProvider: MeterProvider;
+  metricReader: MetricReader;
+  /** Tear down all three providers — called from kernel.dispose(). */
+  shutdown: () => Promise<void>;
+  tracerProvider: WebTracerProvider;
+}
+/**
+ * Constructs the SDK's private OTel providers. `WebTracerProvider` is never
+ * installed globally — it's passed to `registerInstrumentations(...)`
+ * explicitly. `ContextManager` and `TextMapPropagator` are process-wide
+ * singletons; we install ours only when nothing else has claimed them
+ * (`setGlobal*` returns `false` on duplicate). If we lose that race, the
+ * SSR-embedded pageload parent isn't honored — everything else works.
+ *
+ * Kept out of `Kernel` so the error-only bundle path never imports the
+ * OTel SDK.
+ */
+declare function buildOtelProvider(input: OtelProviderInput): {
+  contextManager: PageScopeContextManager;
+  flush: () => Promise<void>;
+  loggerProvider: LoggerProvider;
+  meterProvider: MeterProvider;
+  metricReader: PeriodicExportingMetricReader;
+  shutdown: () => Promise<void>;
+  tracerProvider: WebTracerProvider;
+};
+//#endregion
+export { OtelProviderInput as n, buildOtelProvider as r, OtelProviderHandle as t };

package/dist/provider.d.mts

@@ -1,59 +1,3 @@
-import { ReplayConfig, ReplayOption } from "./plugins/replay/config.mjs";
-import { PluginOverrides } from "./plugins/lib/loader.mjs";
-import { Kernel } from "./internal/kernel.mjs";
-import { InterfereContext, InterfereContextValue } from "./internal/react-context.mjs";
-import { PropsWithChildren, ReactNode } from "react";
-import { ConsentState } from "@interfere/types/sdk/plugins/manifest";
-//#region src/provider.d.ts
-interface InterfereProviderProps extends PropsWithChildren {
-  /**
-   * Consent state gating which plugin categories may run. Omit (or pass
-   * `undefined`) to leave consent unmanaged — every category is allowed.
-   * This is the only place consent is configured; `init()` no longer
-   * accepts it.
-   */
-  consent?: ConsentState | undefined;
-  /**
-   * Auto-install an internal capture boundary around `children` so
-   * render-phase React errors are reported even when the host app has no
-   * `ErrorBoundary` / `error.tsx` of its own.
-   *
-   * The internal boundary is transparent: it captures the error and then
-   * re-throws so upstream boundaries (the customer's own, Next.js's
-   * `error.tsx` / `global-error.tsx`, or React's default unmount) keep full
-   * control of what the user sees. Safe to leave enabled.
-   *
-   * Pass `false` only if you explicitly don't want automatic capture of
-   * render-phase errors — for example, if you've already wired
-   * {@link reactErrorHandler} into `createRoot()`.
-   *
-   * @default true
-   */
-  errorBoundary?: boolean;
-  /**
-   * The active kernel from `init()`. Pass `null` (or omit on the server)
-   * when the SDK isn't initialized — useful during SSR/SSG where `init()`
-   * runs client-side only. The provider mounts with null-safe accessors
-   * and switches to the real kernel once it's available.
-   */
-  kernel: Kernel | null;
-  /**
-   * Per-plugin overrides, merged over the manifest defaults. Generic plugins
-   * are booleans (e.g. `{ pageEvents: false }`). `replay` additionally accepts
-   * a config object — `{ replay: { maskAllInputs: true } }` enables replay
-   * with that masking config; `{ replay: false }` disables it. Privacy classes
-   * are always applied, regardless of config: `interfere-block` elements are
-   * dropped and replay as a same-size placeholder, `interfere-mask` masks the
-   * text of an element and all its children, and `interfere-ignore` stops an
-   * element's input events from being recorded. `input[type="password"]` is
-   * masked by default; use `maskInputOptions`/`maskAllInputs` to mask other
-   * input values. `init()` no longer accepts plugin config; this is the only
-   * place it lives.
-   */
-  plugins?: PluginOverrides | undefined;
-}
-declare function InterfereProvider({ kernel, children, consent, plugins, errorBoundary }: InterfereProviderProps): ReactNode;
-declare function useInterfere(): InterfereContextValue;
-declare function useSession(): string | null;
-//#endregion
+import { a as ReplayOption, i as ReplayConfig } from "./config-Rm-ct4K1.mjs";
+import { S as PluginOverrides, a as InterfereContextValue, i as InterfereContext, n as useInterfere, r as useSession, t as InterfereProvider } from "./provider-50LbJ4Tl.mjs";
 export { InterfereContext, type InterfereContextValue, InterfereProvider, type PluginOverrides, type ReplayConfig, type ReplayOption, useInterfere, useSession };

package/dist/provider.mjs

@@ -1 +1 @@
-"use client";import{InterfereContext,NULL_CONTEXT_VALUE}from"./internal/react-context.mjs";import{CaptureBoundary}from"./internal/capture-boundary.mjs";import{useContext,useEffect}from"react";import{jsx}from"react/jsx-runtime";function InterfereProvider({kernel,children,consent,plugins,errorBoundary=!0}){useEffect(()=>{kernel?.syncProviderConfig({consent,plugins})},[kernel,consent,plugins]);let value=kernel?{consent:kernel.consent,device:kernel.device,identity:kernel.identity,kernel,session:kernel.session}:NULL_CONTEXT_VALUE;return jsx(InterfereContext,{value,children:errorBoundary?jsx(CaptureBoundary,{children}):children})}function useInterfere(){let ctx=useContext(InterfereContext);if(!ctx)throw Error(`useInterfere must be used within <InterfereProvider>`);return ctx}function useSession(){return useInterfere().session.getId()}export{InterfereContext,InterfereProvider,useInterfere,useSession};
+"use client";import{InterfereContext,NULL_CONTEXT_VALUE}from"./internal/react-context.mjs";import{CaptureBoundary}from"./internal/capture-boundary.mjs";import{useContext,useLayoutEffect}from"react";import{c}from"react/compiler-runtime";import{jsx}from"react/jsx-runtime";function InterfereProvider(t0){let $=c(13),{kernel,children,consent,plugins,errorBoundary:t1}=t0,errorBoundary=t1===void 0||t1,t2,t3;$[0]!==consent||$[1]!==kernel||$[2]!==plugins?(t2=()=>{kernel?.syncProviderConfig({consent,plugins})},t3=[kernel,consent,plugins],$[0]=consent,$[1]=kernel,$[2]=plugins,$[3]=t2,$[4]=t3):(t2=$[3],t3=$[4]),useLayoutEffect(t2,t3);let t4;$[5]===kernel?t4=$[6]:(t4=kernel?{consent:kernel.consent,device:kernel.device,identity:kernel.identity,kernel,session:kernel.session}:NULL_CONTEXT_VALUE,$[5]=kernel,$[6]=t4);let value=t4,t5;$[7]!==children||$[8]!==errorBoundary?(t5=errorBoundary?jsx(CaptureBoundary,{children}):children,$[7]=children,$[8]=errorBoundary,$[9]=t5):t5=$[9];let body=t5,t6;return $[10]!==body||$[11]!==value?(t6=jsx(InterfereContext,{value,children:body}),$[10]=body,$[11]=value,$[12]=t6):t6=$[12],t6}function useInterfere(){let ctx=useContext(InterfereContext);if(!ctx)throw Error(`useInterfere must be used within <InterfereProvider>`);return ctx}function useSession(){"use no memo";return useInterfere().session.getId()}export{InterfereContext,InterfereProvider,useInterfere,useSession};