@interfere/react 9.0.2 → 10.0.1-canary.0

package/dist/internal/dom/actionable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionable.mjs","names":[],"sources":["../../../src/internal/dom/actionable.ts"],"sourcesContent":["/**\n * Single source of truth for \"what counts as a clickable element\" across\n * the SDK. Used by both the `pages` plugin (which captures `ui_event`\n * envelopes) and the OTel `UserInteractionInstrumentation` enrichment\n * hook (which gates span creation + stamps target attrs). Before this\n * was extracted, the two sites diverged and produced inconsistent\n * notions of \"actionable.\"\n *\n * `data-track-click` is the customer escape hatch — any element opted\n * in via that attribute is treated as actionable regardless of tag/role.\n */\n\nconst ACTIONABLE_TAGS = new Set([\n  \"a\",\n  \"button\",\n  \"input\",\n  \"select\",\n  \"textarea\",\n  \"summary\",\n  \"label\",\n]);\n\nconst ACTIONABLE_ROLES = new Set([\n  \"button\",\n  \"link\",\n  \"menuitem\",\n  \"tab\",\n  \"checkbox\",\n  \"radio\",\n  \"switch\",\n]);\n\nconst TEXT_TRUNCATE = 120;\n\nexport function isActionable(el: Element): boolean {\n  if (ACTIONABLE_TAGS.has(el.tagName.toLowerCase())) {\n    return true;\n  }\n  const role = el.getAttribute(\"role\");\n  if (role && ACTIONABLE_ROLES.has(role)) {\n    return true;\n  }\n  return el.hasAttribute(\"data-track-click\");\n}\n\nexport function closestActionable(target: EventTarget | null): Element | null {\n  if (!(target instanceof Element)) {\n    return null;\n  }\n  let el: Element | null = target;\n  while (el) {\n    if (isActionable(el)) {\n      return el;\n    }\n    el = el.parentElement;\n  }\n  return null;\n}\n\nexport interface ActionableDescriptor {\n  ariaLabel?: string | undefined;\n  href?: string | undefined;\n  id?: string | undefined;\n  name?: string | undefined;\n  role?: string | undefined;\n  tag: string;\n  text?: string | undefined;\n  [key: string]: unknown;\n}\n\nexport function describeActionable(el: Element): ActionableDescriptor {\n  const desc: ActionableDescriptor = {\n    tag: el.tagName.toLowerCase(),\n  };\n  if (el.id) {\n    desc.id = el.id;\n  }\n  const role = el.getAttribute(\"role\");\n  if (role) {\n    desc.role = role;\n  }\n  const name = el.getAttribute(\"name\");\n  if (name) {\n    desc.name = name;\n  }\n  const ariaLabel = el.getAttribute(\"aria-label\");\n  if (ariaLabel) {\n    desc.ariaLabel = ariaLabel;\n  }\n  if (el instanceof HTMLAnchorElement) {\n    desc.href = el.href;\n  }\n  const text = el.textContent?.trim().slice(0, TEXT_TRUNCATE);\n  if (text) {\n    desc.text = text;\n  }\n  return desc;\n}\n"],"mappings":"AAYA,MAAM,gBAAkB,IAAI,IAAI,CAC9B,IACA,SACA,QACA,SACA,WACA,UACA,OACF,CAAC,EAEK,iBAAmB,IAAI,IAAI,CAC/B,SACA,OACA,WACA,MACA,WACA,QACA,QACF,CAAC,EAID,SAAgB,aAAa,GAAsB,CACjD,GAAI,gBAAgB,IAAI,GAAG,QAAQ,YAAY,CAAC,EAC9C,MAAO,GAET,IAAM,KAAO,GAAG,aAAa,MAAM,EAInC,OAHI,MAAQ,iBAAiB,IAAI,IAAI,EAC5B,GAEF,GAAG,aAAa,kBAAkB,CAC3C,CAEA,SAAgB,kBAAkB,OAA4C,CAC5E,GAAI,EAAE,kBAAkB,SACtB,OAAO,KAET,IAAI,GAAqB,OACzB,KAAO,IAAI,CACT,GAAI,aAAa,EAAE,EACjB,OAAO,GAET,GAAK,GAAG,aACV,CACA,OAAO,IACT,CAaA,SAAgB,mBAAmB,GAAmC,CACpE,IAAM,KAA6B,CACjC,IAAK,GAAG,QAAQ,YAAY,CAC9B,EACI,GAAG,KACL,KAAK,GAAK,GAAG,IAEf,IAAM,KAAO,GAAG,aAAa,MAAM,EAC/B,OACF,KAAK,KAAO,MAEd,IAAM,KAAO,GAAG,aAAa,MAAM,EAC/B,OACF,KAAK,KAAO,MAEd,IAAM,UAAY,GAAG,aAAa,YAAY,EAC1C,YACF,KAAK,UAAY,WAEf,cAAc,oBAChB,KAAK,KAAO,GAAG,MAEjB,IAAM,KAAO,GAAG,aAAa,KAAK,EAAE,MAAM,EAAG,GAAa,EAI1D,OAHI,OACF,KAAK,KAAO,MAEP,IACT"}

package/dist/internal/kernel-registry.d.mts

@@ -0,0 +1,8 @@
+import { Kernel } from "./kernel.mjs";
+
+//#region src/internal/kernel-registry.d.ts
+declare function registerKernel(kernel: Kernel): void;
+declare function unregisterKernel(kernel: Kernel): void;
+declare function activeKernel(): Kernel | null;
+//#endregion
+export { activeKernel, registerKernel, unregisterKernel };

package/dist/internal/kernel-registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-registry.d.mts","names":[],"sources":["../../src/internal/kernel-registry.ts"],"mappings":";;;iBAsBgB,cAAA,CAAe,MAAc,EAAN,MAAM;AAAA,iBAS7B,gBAAA,CAAiB,MAAc,EAAN,MAAM;AAAA,iBAM/B,YAAA,CAAA,GAAgB,MAAM"}

package/dist/internal/kernel-registry.mjs

@@ -0,0 +1 @@
+import{createLogger}from"../util/log.mjs";const log=createLogger(`kernel-registry`);let active=null;function registerKernel(kernel){active&&active!==kernel&&log.warn(`init() called twice with different kernels; later one wins. The public capture()/span() helpers route only to the latest kernel — multi-surface apps should call kernel.recordException() directly.`),active=kernel}function unregisterKernel(kernel){active===kernel&&(active=null)}function activeKernel(){return active}export{activeKernel,registerKernel,unregisterKernel};

package/dist/internal/kernel-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-registry.mjs","names":[],"sources":["../../src/internal/kernel-registry.ts"],"sourcesContent":["import { createLogger } from \"../util/log.js\";\nimport type { Kernel } from \"./kernel.js\";\n\nconst log = createLogger(\"kernel-registry\");\n\n/**\n * Module-scoped active kernel reference. The framework wrapper\n * (`@interfere/next`, `@interfere/vite`) registers its kernel here on\n * `init()` so the public `api.ts` helpers can find it without each customer\n * call site threading the kernel through.\n *\n * Single-kernel by design: each app bundle has its own module instance, so\n * the common case (one app, one init) gets a clean global. The warn on\n * overwrite catches HMR / accidental double-init / module-federated MFEs\n * that share `@interfere/react` across surfaces — those setups need to\n * reach for `kernel.recordException()` directly rather than the registry.\n *\n * @internal Wrappers only. Importing this from app code will silently\n * de-fang the public api helpers.\n */\nlet active: Kernel | null = null;\n\nexport function registerKernel(kernel: Kernel): void {\n  if (active && active !== kernel) {\n    log.warn(\n      \"init() called twice with different kernels; later one wins. The public capture()/span() helpers route only to the latest kernel — multi-surface apps should call kernel.recordException() directly.\"\n    );\n  }\n  active = kernel;\n}\n\nexport function unregisterKernel(kernel: Kernel): void {\n  if (active === kernel) {\n    active = null;\n  }\n}\n\nexport function activeKernel(): Kernel | null {\n  return active;\n}\n"],"mappings":"0CAGA,MAAM,IAAM,aAAa,iBAAiB,EAiB1C,IAAI,OAAwB,KAE5B,SAAgB,eAAe,OAAsB,CAC/C,QAAU,SAAW,QACvB,IAAI,KACF,qMACF,EAEF,OAAS,MACX,CAEA,SAAgB,iBAAiB,OAAsB,CACjD,SAAW,SACb,OAAS,KAEb,CAEA,SAAgB,cAA8B,CAC5C,OAAO,MACT"}

package/dist/internal/kernel.d.mts

@@ -0,0 +1,267 @@
+import { PluginContext } from "../plugins/lib/types.mjs";
+import { PluginOverrides } from "../plugins/lib/loader.mjs";
+import { SessionTracker } from "../tracking/api.mjs";
+import { OtelProviderHandle } from "./otel/provider.mjs";
+import { PluginRuntime } from "./plugin-runtime.mjs";
+import { NonErrorException } from "@interfere/types/sdk/errors";
+import { ConsentState } from "@interfere/types/sdk/plugins/manifest";
+import { ReleaseSlug } from "@interfere/types/releases/slug";
+import { MetricReader } from "@opentelemetry/sdk-metrics";
+import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { IngestedFrame } from "@interfere/types/data/frame";
+import { SessionId } from "@interfere/types/data/session";
+import { IdentifyParams } from "@interfere/types/sdk/identify";
+import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
+
+//#region src/internal/kernel.d.ts
+declare function buildSdkStack(wrapperVersions?: string[]): string[];
+interface KernelOptions {
+  consent?: ConsentState;
+  /**
+   * 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;
+  plugins?: PluginOverrides;
+  /**
+   * Override the OTel `service.name` resource attribute. Defaults to
+   * `"interfere-sdk"`. Customers running multiple frontends in one
+   * monitoring backend (e.g. `"@interfere/homepage"` vs
+   * `"@interfere/dashboard"`) 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 {
+  /**
+   * 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)[];
+  /**
+   * URL patterns that should receive W3C `traceparent` + `baggage`
+   * headers on outgoing fetch / XHR. Same-origin requests always
+   * propagate; this allowlist enables cross-origin propagation
+   * (separate API origin, internal service mesh, etc.).
+   */
+  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;
+}
+/**
+ * @internal
+ * 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.
+ */
+interface KernelInternalOptions extends KernelOptions {
+  /**
+   * Extra log-record processors fanned into the LoggerProvider's
+   * processor list. Used by `@interfere/observability` for internal-only
+   * dual-write to BetterStack from `interfere/homepage` +
+   * `interfere/dashboard`. **Not part of the customer surface** — the
+   * SDK doesn't expose a way to fan-out to other observability vendors.
+   */
+  _internalAdditionalLogRecordProcessors?: LogRecordProcessor[];
+  /**
+   * Extra metric readers fanned into the MeterProvider's reader list.
+   * See `_internalAdditionalLogRecordProcessors`. Used to keep web
+   * vitals histograms landing on the BetterStack-fronting OTel
+   * collector after the rum.ts → SDK migration moved the primary path
+   * to `/v2/sink` (Tinybird-only).
+   */
+  _internalAdditionalMetricReaders?: MetricReader[];
+  /**
+   * Extra span processors fanned into the WebTracerProvider's processor
+   * list. See `_internalAdditionalLogRecordProcessors`.
+   */
+  _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 {
+  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;
+}
+/**
+ * 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 tracker;
+  private readonly seen;
+  private runtime;
+  private otel;
+  private otelDispose;
+  private unsubscribePageHidden;
+  constructor(tracker: SessionTracker);
+  /** @internal Bound by `createKernel` immediately after construction. */
+  attachRuntime(runtime: PluginRuntime): void;
+  private requireRuntime;
+  /** PluginContext shim: plugins expect a non-null string. */
+  getSessionId(): string;
+  /**
+   * 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;
+  /**
+   * 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>;
+  /**
+   * @internal 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`.
+   */
+  attachOtel(handle: OtelProviderHandle, dispose: () => void): void;
+  /**
+   * Provider-driven consent sync. Pass `undefined` to clear consent (treats
+   * the prop as "unmanaged"); pass a state to apply it.
+   */
+  syncConsent(value: ConsentState | undefined): void;
+  dispose(): Promise<void>;
+}
+interface CreateKernelInput {
+  opts?: KernelInternalOptions;
+}
+/**
+ * Pure construction graph. Awaits the remote-config fetch before resolving,
+ * so the runtime sees a fully-applied config before any capture is attempted
+ * by the caller. Removes the capture-before-config race the old `Client`
+ * had.
+ */
+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(): ReleaseSlug | null;
+//#endregion
+export { Kernel, KernelConsent, KernelDevice, KernelIdentity, KernelInternalOptions, KernelOptions, KernelSession, RecordExceptionOpts, TracingOptions, buildSdkStack, createKernel, isEnabledByEnvironment, readReleaseSlugFromGlobals };

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.mts","names":[],"sources":["../../src/internal/kernel.ts"],"mappings":";;;;;;;;;;;;;;;;;iBAyCgB,aAAA,CAAc,eAA0B;AAAA,UAyDvC,aAAA;EACf,OAAA,GAAU,YAAA;EA1DI;;;;AAAwC;AAyDxD;;EASE,OAAA;EARU;EAUV,KAAA,UAAe,UAAA,CAAW,KAAA;EAC1B,OAAA,GAAU,eAAA;EAgBU;;;;;;;EARpB,WAAA;EAT0B;;;;;;;EAiB1B,OAAA,aAAoB,cAAA;AAAA;;;;;;;UASL,cAAA;EAsBf;;;;AAMS;AAUX;EA/BE,UAAA,aAAuB,MAAA;;;;;;;EAOvB,oBAAA,aAAiC,MAAM;EAwBM;;;;;;;EAhB7C,YAAA,IAAgB,QAAA;EAuCA;AAAA;AAGlB;;;EApCE,SAAA;AAAA;;;;;;AAsCwB;AAG1B;UA/BiB,qBAAA,SAA8B,aAAA;;;;;;;;EAQ7C,sCAAA,GAAyC,kBAAA;EAyBzC;;;;;AAAoC;AAGtC;EApBE,gCAAA,GAAmC,YAAA;;;AAsB1B;AAGX;EApBE,iCAAA,GAAoC,aAAA;;EAEpC,gBAAA;AAAA;AAAA,UAGe,aAAA;EACf,GAAA,IAAO,YAAA;EACP,GAAA,CAAI,KAAA,GAAQ,YAAY;AAAA;AAAA,UAGT,cAAA;EACf,GAAA,IAAO,cAAA;EACP,GAAA,CAAI,MAAA,EAAQ,cAAA,GAAiB,OAAA;AAAA;AAAA,UAGd,YAAA;EACf,WAAA;EACA,SAAS;AAAA;AAAA,UAGM,aAAA;EACf,KAAA,IAAS,SAAS;EAClB,WAAA;AAAA;AAAA,UAGe,mBAAA;EAuBN;;;AAAyB;AAcpC;;EAdW,SAhBA,YAAA,YAAwB,aAAA;EA+Bf;;;;;;;EAAA,SAvBT,WAAA;EA0HD;;;;;;EAAA,SAnHC,cAAA,YAA0B,aAAA;EAAA,SAC1B,SAAA,EAAW,cAAA;AAAA;;;;;;;;;;;;cAcT,MAAA,YAAkB,aAAA;EAAA,SACpB,OAAA,EAAS,aAAA;EAAA,SACT,QAAA,EAAU,cAAA;EAAA,SACV,MAAA,EAAQ,YAAA;EAAA,SACR,OAAA,EAAS,aAAA;EAAA,iBAED,OAAA;EAAA,iBAGA,IAAA;EAAA,QAKT,OAAA;EAAA,QACA,IAAA;EAAA,QACA,WAAA;EAAA,QACA,qBAAA;cAEI,OAAA,EAAS,cAAA;EA+ErB;EAtCA,aAAA,CAAc,OAAA,EAAS,aAAA;EAAA,QAIf,cAAA;EAmCN;EAzBF,YAAA,CAAA;EA0BE;;;;;;;;;;;;;;;;;;;;EAFF,eAAA,CACE,KAAA,EAAO,KAAA,GAAQ,iBAAA,EACf,IAAA,EAAM,mBAAA;EA6HA;;;;AACoB;AAS9B;;EAlFE,SAAA,CAAU,KAAA;IACR,YAAA;IACA,cAAA;IACA,IAAA;IACA,UAAA,GAAa,MAAA;EAAA;EA+ER;;;;;AACQ;AA4PjB;EAxTQ,KAAA,CAAA,GAAS,OAAA;;;AAwTqB;AAyBtC;;;;EApUE,UAAA,CAAW,MAAA,EAAQ,kBAAA,EAAoB,OAAA;;;;;EASvC,WAAA,CAAY,KAAA,EAAO,YAAA;EASb,OAAA,CAAA,GAAW,OAAA;AAAA;AAAA,UAiBT,iBAAA;EACR,IAAA,GAAO,qBAAqB;AAAA;;;;;;;iBASR,YAAA,CACpB,KAAA,GAAO,iBAAA,GACN,OAAA,CAAQ,MAAA;AAAA,iBA4PK,sBAAA,CAAA;;;;;;;;;;;;iBAyBA,0BAAA,CAAA,GAA8B,WAAW"}

package/dist/internal/kernel.mjs

@@ -0,0 +1 @@
+import{createLogger}from"../util/log.mjs";import{getGlobal}from"../util/global.mjs";import{resolveTargets}from"./config.mjs";import{SessionTracker}from"../tracking/api.mjs";import{safeStringify}from"../util/stringify.mjs";import{onPageHidden}from"./page-lifecycle.mjs";import{PluginRuntime}from"./plugin-runtime.mjs";import{registerServiceWorker}from"./sw.mjs";import{PRODUCER_VERSION}from"./version.mjs";import{isNonErrorException,shouldDropBrowserExtensionNoise,shouldDropUnresolvableStack,toExceptions}from"@interfere/types/sdk/errors";import{trace}from"@opentelemetry/api";import{releaseSlugSchema}from"@interfere/types/releases/slug";const log=createLogger(`kernel`),TRAILING_SLASH_RE=/\/$/;function buildSdkStack(wrapperVersions){return[...wrapperVersions??[],PRODUCER_VERSION]}function buildExceptionEventAttrs(value,opts){let attrs={"interfere.exception.mechanism":opts.mechanism.type,"interfere.exception.handled":String(opts.mechanism.handled)};return opts.errorDigest&&(attrs[`interfere.error.digest`]=opts.errorDigest),isNonErrorException(value)?(attrs[`exception.type`]=value.type,attrs[`exception.message`]=value.value,attrs[`interfere.exception.kind`]=`non-error`,attrs[`interfere.exception.serialized`]=safeStringify(value.serialized),attrs):(attrs[`exception.type`]=value.name,attrs[`exception.message`]=value.message,attrs[`interfere.exception.kind`]=`error`,value.stack&&(attrs[`exception.stacktrace`]=value.stack),attrs[`interfere.exception.chain`]=safeStringify(toExceptions(value,opts.mechanism)),opts.appendFrames&&opts.appendFrames.length>0&&(attrs[`interfere.exception.appended_frames`]=safeStringify(opts.appendFrames)),opts.fallbackFrames&&opts.fallbackFrames.length>0&&(attrs[`interfere.exception.fallback_frames`]=safeStringify(opts.fallbackFrames)),attrs)}var Kernel=class{consent;identity;device;session;tracker;seen=new WeakSet;runtime=null;otel=null;otelDispose=null;unsubscribePageHidden=null;constructor(tracker){this.tracker=tracker,this.consent={get:()=>this.requireRuntime().getConsent(),set:value=>{let runtime=this.requireRuntime();value?runtime.setConsent(value):runtime.resetConsent()}},this.identity={get:()=>this.tracker.getIdentity(),set:params=>this.tracker.identify(params)},this.device={getDeviceId:()=>this.tracker.getDeviceId(),getFpHash:()=>this.tracker.getFpHash()},this.session={getId:()=>this.tracker.sessionId(),getWindowId:()=>this.tracker.windowId()},this.unsubscribePageHidden=onPageHidden(()=>{this.flush().catch(()=>void 0)})}attachRuntime(runtime){this.runtime=runtime}requireRuntime(){if(!this.runtime)throw Error(`Kernel runtime not attached. createKernel must call attachRuntime before any consent/dispose path runs.`);return this.runtime}getSessionId(){return this.tracker.sessionId()??``}recordException(value,opts){if(!isNonErrorException(value)){if(this.seen.has(value))return;this.seen.add(value)}if(!isNonErrorException(value)){let stacks=[],current=value;for(let depth=0;current&&depth<5;depth+=1)current.stack&&stacks.push(current.stack),current=current.cause instanceof Error?current.cause:void 0;if(shouldDropBrowserExtensionNoise(stacks)||shouldDropUnresolvableStack(stacks))return}let span=trace.getActiveSpan();span&&span.addEvent(`exception`,buildExceptionEventAttrs(value,opts))}recordLog(input){this.otel&&this.otel.loggerProvider.getLogger(`@interfere/react`).emit({severityText:input.severityText,severityNumber:input.severityNumber,body:input.body,...input.attributes?{attributes:input.attributes}:{}})}async flush(){this.otel&&await this.otel.flush()}attachOtel(handle,dispose){this.otel=handle,this.otelDispose=dispose}syncConsent(value){let runtime=this.requireRuntime();if(value){runtime.setConsent(value);return}runtime.resetConsent()}async dispose(){this.unsubscribePageHidden?.(),this.unsubscribePageHidden=null,this.runtime&&await this.runtime.dispose(),this.tracker.dispose(),this.otelDispose?.(),this.otelDispose=null,this.otel&&=(await this.otel.shutdown(),null)}};async function createKernel(input={}){let{opts={}}=input,fetcher=opts.fetch??globalThis.fetch.bind(globalThis),targets=resolveTargets();log.info(`collector: %s`,targets.collectorBaseUrl),getGlobal(`__INTERFERE_FORCE_ENABLE__`)&&log.warn(`FORCE_ENABLE is active. Events will be dropped by production collectors. This should only be set during local development.`);let tracker=new SessionTracker({target:targets.session,fetcher});opts._wrapperVersions?.length&&(globalThis.__INTERFERE_SDK_STACK__=opts._wrapperVersions);let kernel=new Kernel(tracker),runtime=new PluginRuntime(kernel,opts.plugins,opts.consent);if(kernel.attachRuntime(runtime),tracker.start(),runtime.start(),opts.tracing!==!1){let tracingOpts=typeof opts.tracing==`object`?opts.tracing:void 0;await wireOtel(kernel,targets,opts._wrapperVersions,{...tracingOpts??{},...opts.serviceName?{serviceName:opts.serviceName}:{},...opts._internalAdditionalSpanProcessors?{additionalSpanProcessors:opts._internalAdditionalSpanProcessors}:{},...opts._internalAdditionalLogRecordProcessors?{additionalLogRecordProcessors:opts._internalAdditionalLogRecordProcessors}:{},...opts._internalAdditionalMetricReaders?{additionalMetricReaders:opts._internalAdditionalMetricReaders}:{}})}return await fetchRemoteConfig(targets.config,fetcher,runtime),registerServiceWorker({onMessage:msg=>recordSwMessage(kernel,msg)}).catch(()=>{}),kernel}function recordSwMessage(kernel,msg){kernel.recordLog({severityText:`info`,severityNumber:9,body:msg.type,attributes:{"url.full":msg.url,...msg.reason?{"interfere.sw.reason":msg.reason}:{}}})}async function wireOtel(kernel,targets,wrapperVersions,tracing){let{buildOtelProvider,captureWebVitals,readPropagationFromDocument,registerBundledInstrumentations}=await import(`./otel/index.mjs`),collectorUrl=targets.collectorBaseUrl.replace(TRAILING_SLASH_RE,``),releaseSlug=readReleaseSlugFromGlobals(),handle=buildOtelProvider({collectorUrl,authHeaders:targets.ingest.headers,sdkStack:buildSdkStack(wrapperVersions),getSessionId:()=>kernel.session.getId(),deviceId:kernel.device.getDeviceId(),releaseSlug,...tracing.serviceName?{serviceName:tracing.serviceName}:{},...tracing.additionalSpanProcessors?{additionalSpanProcessors:tracing.additionalSpanProcessors}:{},...tracing.additionalLogRecordProcessors?{additionalLogRecordProcessors:tracing.additionalLogRecordProcessors}:{},...tracing.additionalMetricReaders?{additionalMetricReaders:tracing.additionalMetricReaders}:{}}),extracted=readPropagationFromDocument();extracted&&handle.contextManager.setPageScope(extracted);let dispose=registerBundledInstrumentations({tracerProvider:handle.tracerProvider,ignoreUrls:[`${collectorUrl}/v2/sink`,targets.config.url,targets.session.url],...tracing.propagateContextUrls?{propagateContextUrls:tracing.propagateContextUrls}:{},...tracing.resolveRoute?{resolveRoute:tracing.resolveRoute}:{}});tracing.webVitals!==!1&&captureWebVitals({meter:handle.meterProvider.getMeter(`@interfere/react/web-vitals`),flush:()=>handle.flush(),...tracing.resolveRoute?{resolveRoute:tracing.resolveRoute}:{}}),kernel.attachOtel(handle,dispose)}async function fetchRemoteConfig(configTarget,fetcher,runtime){try{let headers=Object.fromEntries(configTarget.headers.entries()),res=await fetcher(configTarget.url,{method:`GET`,headers,signal:AbortSignal.timeout(1e4)});if(!res.ok)return;let config=await res.json();config?.plugins&&(runtime.applyRemoteConfig(config.plugins),log.debug(`applied remote config`))}catch{log.warn(`remote config fetch failed, using local defaults`)}}function isEnabledByEnvironment(){if(typeof process>`u`||!process.env)return!0;let nodeEnv=process.env.NODE_ENV;return nodeEnv===`production`||nodeEnv===void 0?!0:!!(getGlobal(`__INTERFERE_FORCE_ENABLE__`)||process.env.INTERFERE_FORCE_ENABLE)}function readReleaseSlugFromGlobals(){let value=getGlobal(`__INTERFERE_RELEASE_SLUG__`);return typeof value==`string`?releaseSlugSchema.parse(value):null}export{Kernel,buildSdkStack,createKernel,isEnabledByEnvironment,readReleaseSlugFromGlobals};

package/dist/internal/kernel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.mjs","names":[],"sources":["../../src/internal/kernel.ts"],"sourcesContent":["import type { IngestedFrame } from \"@interfere/types/data/frame\";\nimport type { SessionId } from \"@interfere/types/data/session\";\nimport {\n  type ReleaseSlug,\n  releaseSlugSchema,\n} from \"@interfere/types/releases/slug\";\nimport {\n  isNonErrorException,\n  type NonErrorException,\n  shouldDropBrowserExtensionNoise,\n  shouldDropUnresolvableStack,\n  toExceptions,\n} from \"@interfere/types/sdk/errors\";\nimport type { IdentifyParams } from \"@interfere/types/sdk/identify\";\nimport type { ConsentState } from \"@interfere/types/sdk/plugins/manifest\";\nimport type { ErrorMechanism } from \"@interfere/types/sdk/plugins/payload/errors\";\nimport type { RemoteConfig } from \"@interfere/types/sdk/remote-config\";\n\nimport { trace } from \"@opentelemetry/api\";\nimport type { LogRecordProcessor } from \"@opentelemetry/sdk-logs\";\nimport type { MetricReader } from \"@opentelemetry/sdk-metrics\";\nimport type { SpanProcessor } from \"@opentelemetry/sdk-trace-base\";\n\nimport type { PluginOverrides } from \"../plugins/lib/loader.js\";\nimport type { PluginContext } from \"../plugins/lib/types.js\";\nimport { SessionTracker } from \"../tracking/api.js\";\nimport { getGlobal } from \"../util/global.js\";\nimport { createLogger } from \"../util/log.js\";\nimport { safeStringify } from \"../util/stringify.js\";\nimport type { AuthHeaders, IngestTarget } from \"./config.js\";\nimport { resolveTargets } from \"./config.js\";\nimport type { OtelProviderHandle } from \"./otel/index.js\";\nimport { onPageHidden } from \"./page-lifecycle.js\";\nimport { PluginRuntime } from \"./plugin-runtime.js\";\nimport { registerServiceWorker, type SwMessage } from \"./sw.js\";\nimport { PRODUCER_VERSION } from \"./version.js\";\n\nconst log = createLogger(\"kernel\");\n\nconst TRAILING_SLASH_RE = /\\/$/;\n\nexport function buildSdkStack(wrapperVersions?: string[]): string[] {\n  return [...(wrapperVersions ?? []), PRODUCER_VERSION];\n}\n\nfunction buildExceptionEventAttrs(\n  value: Error | NonErrorException,\n  opts: RecordExceptionOpts\n): Record<string, string> {\n  const attrs: Record<string, string> = {\n    \"interfere.exception.mechanism\": opts.mechanism.type,\n    \"interfere.exception.handled\": String(opts.mechanism.handled),\n  };\n  if (opts.errorDigest) {\n    attrs[\"interfere.error.digest\"] = opts.errorDigest;\n  }\n  if (isNonErrorException(value)) {\n    attrs[\"exception.type\"] = value.type;\n    attrs[\"exception.message\"] = value.value;\n    attrs[\"interfere.exception.kind\"] = \"non-error\";\n    // OTel attrs are scalars; serialize the structured payload so the\n    // OTLP mapper can reconstruct it server-side.\n    attrs[\"interfere.exception.serialized\"] = safeStringify(value.serialized);\n    return attrs;\n  }\n  attrs[\"exception.type\"] = value.name;\n  attrs[\"exception.message\"] = value.message;\n  attrs[\"interfere.exception.kind\"] = \"error\";\n  if (value.stack) {\n    attrs[\"exception.stacktrace\"] = value.stack;\n  }\n  // Walk Error.cause and ship every entry on a single attr. Each entry\n  // carries `{type, value, mechanism?, kind, stack}` — the SDK does not\n  // parse stacks; the collector parses `stack` server-side.\n  attrs[\"interfere.exception.chain\"] = safeStringify(\n    toExceptions(value, opts.mechanism)\n  );\n  // Supplementary frames the SDK has runtime context to assemble that\n  // the server can't synthesise from the raw stack:\n  //   - `appendFrames`: parsed React component-stack frames (regex\n  //     parser stays in the SDK — React-specific format, tiny).\n  //   - `fallbackFrames`: source/line/col tuple from `window.onerror`\n  //     when the Error's `.stack` is degenerate (CORS-masked, etc.).\n  // The collector mapper merges these into the `frames` column after\n  // parsing the raw JS stack.\n  if (opts.appendFrames && opts.appendFrames.length > 0) {\n    attrs[\"interfere.exception.appended_frames\"] = safeStringify(\n      opts.appendFrames\n    );\n  }\n  if (opts.fallbackFrames && opts.fallbackFrames.length > 0) {\n    attrs[\"interfere.exception.fallback_frames\"] = safeStringify(\n      opts.fallbackFrames\n    );\n  }\n  return attrs;\n}\n\nexport interface KernelOptions {\n  consent?: ConsentState;\n  /**\n   * Override the automatic dev-mode guard. When `undefined`, the SDK\n   * auto-detects: it disables itself if `process.env[\"NODE_ENV\"]` is not\n   * `\"production\"` (Node / webpack / Next.js). In environments where\n   * `process` does not exist (Vite, CRA, plain browser) the SDK\n   * defaults to **enabled** — pass `false` to disable explicitly.\n   */\n  enabled?: boolean;\n  /** Override `globalThis.fetch` for tests / non-browser hosts. */\n  fetch?: typeof globalThis.fetch;\n  plugins?: PluginOverrides;\n  /**\n   * Override the OTel `service.name` resource attribute. Defaults to\n   * `\"interfere-sdk\"`. Customers running multiple frontends in one\n   * monitoring backend (e.g. `\"@interfere/homepage\"` vs\n   * `\"@interfere/dashboard\"`) set this so spans/metrics/logs slice\n   * cleanly by surface.\n   */\n  serviceName?: string;\n  /**\n   * `false` skips the OTel module entirely — the bundler code-splits\n   * `internal/otel/*` out of this path so the error-only bundle never\n   * imports the OTel SDK. `true` (default) loads it with default\n   * instrumentation config. An object loads it with the supplied\n   * config.\n   */\n  tracing?: boolean | TracingOptions;\n}\n\n/**\n * Per-instrumentation tuning. Every field is optional; defaults match\n * what `interfere/homepage` and `interfere/dashboard` use today via\n * the internal `observability/browser/rum.ts`. New customers don't\n * need to touch any of these — sensible defaults ship out of the box.\n */\nexport interface TracingOptions {\n  /**\n   * Additional URL patterns to skip when creating fetch / XHR spans.\n   * The SDK's own collector endpoint is always ignored; customer-side\n   * third-party SDKs (Clerk, Sentry, GTM, etc.) are also skipped by\n   * default — supplement with anything specific to your app.\n   */\n  ignoreUrls?: (string | RegExp)[];\n  /**\n   * URL patterns that should receive W3C `traceparent` + `baggage`\n   * headers on outgoing fetch / XHR. Same-origin requests always\n   * propagate; this allowlist enables cross-origin propagation\n   * (separate API origin, internal service mesh, etc.).\n   */\n  propagateContextUrls?: (string | RegExp)[];\n  /**\n   * Resolve a URL pathname to a low-cardinality route template\n   * (e.g. `/blog/[slug]`). Without this, dynamic routes produce one\n   * unique span / metric label per visited slug — a cardinality\n   * hazard. Used by fetch, document-load resource enrichment,\n   * user-interaction, long-task, and web-vitals.\n   */\n  resolveRoute?: (pathname: string) => string | undefined;\n  /**\n   * `false` disables Core Web Vitals capture (LCP/FCP/TTFB/INP/CLS).\n   * Defaults to enabled; customers who run their own vitals reporting\n   * can opt out.\n   */\n  webVitals?: boolean;\n}\n\n/**\n * @internal\n * Framework wrappers (`@interfere/next`, `@interfere/vite`) pass extra\n * fields through `createKernel` that customers never set themselves.\n * Kept off the customer-facing `KernelOptions` to make the public surface\n * clean.\n */\nexport interface KernelInternalOptions extends KernelOptions {\n  /**\n   * Extra log-record processors fanned into the LoggerProvider's\n   * processor list. Used by `@interfere/observability` for internal-only\n   * dual-write to BetterStack from `interfere/homepage` +\n   * `interfere/dashboard`. **Not part of the customer surface** — the\n   * SDK doesn't expose a way to fan-out to other observability vendors.\n   */\n  _internalAdditionalLogRecordProcessors?: LogRecordProcessor[];\n  /**\n   * Extra metric readers fanned into the MeterProvider's reader list.\n   * See `_internalAdditionalLogRecordProcessors`. Used to keep web\n   * vitals histograms landing on the BetterStack-fronting OTel\n   * collector after the rum.ts → SDK migration moved the primary path\n   * to `/v2/sink` (Tinybird-only).\n   */\n  _internalAdditionalMetricReaders?: MetricReader[];\n  /**\n   * Extra span processors fanned into the WebTracerProvider's processor\n   * list. See `_internalAdditionalLogRecordProcessors`.\n   */\n  _internalAdditionalSpanProcessors?: SpanProcessor[];\n  /** Wrapper SDK versions (e.g. `@interfere/next@10.0.0`). */\n  _wrapperVersions?: string[];\n}\n\nexport interface KernelConsent {\n  get(): ConsentState | null;\n  set(value?: ConsentState): void;\n}\n\nexport interface KernelIdentity {\n  get(): IdentifyParams | null;\n  set(params: IdentifyParams): Promise<void>;\n}\n\nexport interface KernelDevice {\n  getDeviceId(): string | null;\n  getFpHash(): string | null;\n}\n\nexport interface KernelSession {\n  getId(): SessionId | null;\n  getWindowId(): string | null;\n}\n\nexport interface RecordExceptionOpts {\n  /**\n   * Frames always appended to the first exception's stack. Used by\n   * `<ErrorBoundary>` to inject React's component-stack frames as\n   * supplementary context — these add on top of the real JS frames, they\n   * don't replace them.\n   */\n  readonly appendFrames?: readonly IngestedFrame[];\n  /**\n   * `error.digest` from React when an RSC server-side throw is\n   * sanitised and rebuilt as a synthetic Error on the client. The only\n   * identifier that pairs the redacted client capture with the\n   * unredacted server capture — enrichment mixes this into the\n   * fingerprint so both events group as one problem.\n   */\n  readonly errorDigest?: string;\n  /**\n   * Frames adopted only when the first exception's parsed stack is empty.\n   * Used by the `window.onerror` handler when the browser hands us\n   * source/line/col but the `Error` itself has a degenerate stack — never\n   * glued on top of a real stack.\n   */\n  readonly fallbackFrames?: readonly IngestedFrame[];\n  readonly mechanism: ErrorMechanism;\n}\n\n/**\n * The replacement for the old `Client` god-object. Pure construction graph\n * via `createKernel`; no module-level mutable state, no global lookups.\n * Framework wrappers (`@interfere/next`, `@interfere/vite`) own the\n * singleton lifecycle.\n *\n * Implements `PluginContext` directly: plugins are wired with the kernel\n * itself rather than a closure adapter. The kernel⇄runtime cycle is\n * resolved by constructing the kernel first and binding the runtime via\n * `attachRuntime` immediately after.\n */\nexport class Kernel implements PluginContext {\n  readonly consent: KernelConsent;\n  readonly identity: KernelIdentity;\n  readonly device: KernelDevice;\n  readonly session: KernelSession;\n\n  private readonly tracker: SessionTracker;\n  // Single dedup authority for `recordException`. WeakSet so GC'd errors\n  // don't pin memory. Upstream callers do not pre-filter.\n  private readonly seen = new WeakSet<Error>();\n  // Lateinit. `createKernel` constructs the kernel first, then the runtime\n  // (passing the kernel as `PluginContext`), then calls `attachRuntime`.\n  // Anything kernel-side that touches `runtime` (consent / dispose) runs\n  // after the bind.\n  private runtime: PluginRuntime | null = null;\n  private otel: OtelProviderHandle | null = null;\n  private otelDispose: (() => void) | null = null;\n  private unsubscribePageHidden: (() => void) | null = null;\n\n  constructor(tracker: SessionTracker) {\n    this.tracker = tracker;\n\n    this.consent = {\n      get: () => this.requireRuntime().getConsent(),\n      set: (value) => {\n        const runtime = this.requireRuntime();\n        if (value) {\n          runtime.setConsent(value);\n        } else {\n          runtime.resetConsent();\n        }\n      },\n    };\n\n    this.identity = {\n      get: () => this.tracker.getIdentity(),\n      set: (params) => this.tracker.identify(params),\n    };\n\n    this.device = {\n      getDeviceId: () => this.tracker.getDeviceId(),\n      getFpHash: () => this.tracker.getFpHash(),\n    };\n\n    this.session = {\n      getId: () => this.tracker.sessionId(),\n      getWindowId: () => this.tracker.windowId(),\n    };\n\n    // Force-flush the OTel exporters when the tab is about to be hidden.\n    // Tail spans + web vitals (CLS/INP fire on visibility hidden) are\n    // otherwise lost when the user navigates away. Subscription removed\n    // in `dispose()`.\n    this.unsubscribePageHidden = onPageHidden(() => {\n      // Fire-and-forget — we can't block the unload path.\n      this.flush().catch(() => undefined);\n    });\n  }\n\n  /** @internal Bound by `createKernel` immediately after construction. */\n  attachRuntime(runtime: PluginRuntime): void {\n    this.runtime = runtime;\n  }\n\n  private requireRuntime(): PluginRuntime {\n    if (!this.runtime) {\n      throw new Error(\n        \"Kernel runtime not attached. createKernel must call attachRuntime before any consent/dispose path runs.\"\n      );\n    }\n    return this.runtime;\n  }\n\n  /** PluginContext shim: plugins expect a non-null string. */\n  getSessionId(): string {\n    return this.tracker.sessionId() ?? \"\";\n  }\n\n  /**\n   * Records an exception event on the active OTel span. No envelope\n   * path — the SDK is OTel-only. Single dedup boundary: drops repeats\n   * of the same `Error` instance, plus browser-extension noise and\n   * unresolvable stacks. Upstream callers (the errors plugin's\n   * `window.onerror` / `console.error` / `unhandledrejection`, the\n   * React error boundary) just call this — they don't pre-filter.\n   *\n   * Does NOT mark the active span as failed. A console.error inside a\n   * customer-owned `span()` block would otherwise taint the customer's\n   * span even when the customer caught the error explicitly. The\n   * customer's `span()` helper sets status itself when it observes a\n   * throw.\n   *\n   * `appendFrames` are always appended (component-stack supplements);\n   * `fallbackFrames` are only adopted when the parsed stack is empty\n   * (`window.onerror` source/line/col when the Error has no usable\n   * stack). Both ride on the serialised `interfere.exception.chain`\n   * attribute when the chain is non-trivial.\n   */\n  recordException(\n    value: Error | NonErrorException,\n    opts: RecordExceptionOpts\n  ): void {\n    // Dedup applies only to real Errors. NonErrorException is a fresh\n    // object on every capture site (`toException(event.reason)` allocates\n    // it inline) so the WeakSet would never see a repeat anyway.\n    if (!isNonErrorException(value)) {\n      if (this.seen.has(value)) {\n        return;\n      }\n      this.seen.add(value);\n    }\n\n    // Noise filters operate on the raw stack strings — Error variants\n    // only. Non-Error rejections carry no stack to inspect, but they\n    // ship structured payloads the agent can reason over directly, so\n    // they're never dropped here.\n    if (!isNonErrorException(value)) {\n      const stacks: string[] = [];\n      let current: Error | undefined = value;\n      for (let depth = 0; current && depth < 5; depth += 1) {\n        if (current.stack) {\n          stacks.push(current.stack);\n        }\n        current = current.cause instanceof Error ? current.cause : undefined;\n      }\n      if (\n        shouldDropBrowserExtensionNoise(stacks) ||\n        shouldDropUnresolvableStack(stacks)\n      ) {\n        return;\n      }\n    }\n\n    // Stamp our mechanism taxonomy onto the OTel exception event so the\n    // collector mapper can recover handled / unhandled and the\n    // originating mechanism (browser.onerror / unhandledrejection /\n    // manual.api.capture / etc.). OTel's standard `recordException`\n    // only carries type/message/stack; mechanism is our enrichment, so\n    // we emit the event ourselves via `addEvent` with the full attr\n    // set.\n    const span = trace.getActiveSpan();\n    if (span) {\n      span.addEvent(\"exception\", buildExceptionEventAttrs(value, opts));\n    }\n  }\n\n  /**\n   * Emits an OTel `LogRecord` via the kernel's logger provider. Used by\n   * `plugins/logs.ts` to capture string-only `console.*` calls (the\n   * errors plugin still owns Error-bearing console calls — class\n   * boundary). No-ops when OTel is not wired (`tracing: false`) since\n   * there's no logger provider to emit through.\n   */\n  recordLog(input: {\n    severityText: string;\n    severityNumber: number;\n    body: string;\n    attributes?: Record<string, string>;\n  }): void {\n    if (!this.otel) {\n      return;\n    }\n    this.otel.loggerProvider.getLogger(\"@interfere/react\").emit({\n      severityText: input.severityText,\n      severityNumber: input.severityNumber,\n      body: input.body,\n      ...(input.attributes ? { attributes: input.attributes } : {}),\n    });\n  }\n\n  /**\n   * Force-flushes the OTel exporters. Returns once they've settled\n   * (success or failure) so callers driving unload — page-lifecycle\n   * handlers, integration test teardown — can actually await\n   * completion. The OTel SDK swallows export errors internally; we\n   * surface the resolution either way.\n   */\n  async flush(): Promise<void> {\n    if (this.otel) {\n      await this.otel.flush();\n    }\n  }\n\n  /**\n   * @internal Wired by `createKernel` after the OTel module has been\n   * lazy-loaded. Held on the kernel so `flush()` and `dispose()` can fan\n   * out to the providers. The tracer/meter providers stay private —\n   * customers don't get raw OTel access; the public surface is the\n   * `span()` / `capture()` helpers in `api.ts`.\n   */\n  attachOtel(handle: OtelProviderHandle, dispose: () => void): void {\n    this.otel = handle;\n    this.otelDispose = dispose;\n  }\n\n  /**\n   * Provider-driven consent sync. Pass `undefined` to clear consent (treats\n   * the prop as \"unmanaged\"); pass a state to apply it.\n   */\n  syncConsent(value: ConsentState | undefined): void {\n    const runtime = this.requireRuntime();\n    if (value) {\n      runtime.setConsent(value);\n      return;\n    }\n    runtime.resetConsent();\n  }\n\n  async dispose(): Promise<void> {\n    this.unsubscribePageHidden?.();\n    this.unsubscribePageHidden = null;\n    if (this.runtime) {\n      await this.runtime.dispose();\n    }\n    this.tracker.dispose();\n\n    this.otelDispose?.();\n    this.otelDispose = null;\n    if (this.otel) {\n      await this.otel.shutdown();\n      this.otel = null;\n    }\n  }\n}\n\ninterface CreateKernelInput {\n  opts?: KernelInternalOptions;\n}\n\n/**\n * Pure construction graph. Awaits the remote-config fetch before resolving,\n * so the runtime sees a fully-applied config before any capture is attempted\n * by the caller. Removes the capture-before-config race the old `Client`\n * had.\n */\nexport async function createKernel(\n  input: CreateKernelInput = {}\n): Promise<Kernel> {\n  const { opts = {} } = input;\n  const fetcher = opts.fetch ?? globalThis.fetch.bind(globalThis);\n  const targets = resolveTargets();\n\n  log.info(\"collector: %s\", targets.collectorBaseUrl);\n\n  // Misconfigured prod (NODE_ENV missing/wrong + force-enable on) would\n  // happily ship the header to a prod collector and have every event\n  // silently dropped. The collector returns a structured `dropped` reason\n  // so dev tools can surface it, but the warning here is the first line\n  // of defense — fires at most once per kernel construction.\n  if (getGlobal<boolean>(\"__INTERFERE_FORCE_ENABLE__\")) {\n    log.warn(\n      \"FORCE_ENABLE is active. Events will be dropped by production collectors. This should only be set during local development.\"\n    );\n  }\n\n  const tracker = new SessionTracker({ target: targets.session, fetcher });\n\n  // Single write site for the SDK-stack global. The OTLP exporter\n  // headers and the OTel resource attribute both attribute events to\n  // the producer chain (`@interfere/next@10.0.0`,\n  // `@interfere/react@10.0.0`, …). Wrapper passes `_wrapperVersions`;\n  // the kernel publishes the resulting stack here.\n  if (opts._wrapperVersions?.length) {\n    (globalThis as Record<string, unknown>)[\"__INTERFERE_SDK_STACK__\"] =\n      opts._wrapperVersions;\n  }\n\n  // Resolve the kernel⇄runtime cycle by constructing the kernel first\n  // (without runtime), then the runtime with the kernel as PluginContext,\n  // then binding. No closure adapter — plugins call the kernel directly.\n  const kernel = new Kernel(tracker);\n  const runtime = new PluginRuntime(kernel, opts.plugins, opts.consent);\n  kernel.attachRuntime(runtime);\n\n  tracker.start();\n  runtime.start();\n\n  if (opts.tracing !== false) {\n    const tracingOpts =\n      typeof opts.tracing === \"object\" ? opts.tracing : undefined;\n    await wireOtel(kernel, targets, opts._wrapperVersions, {\n      ...(tracingOpts ?? {}),\n      ...(opts.serviceName ? { serviceName: opts.serviceName } : {}),\n      ...(opts._internalAdditionalSpanProcessors\n        ? {\n            additionalSpanProcessors: opts._internalAdditionalSpanProcessors,\n          }\n        : {}),\n      ...(opts._internalAdditionalLogRecordProcessors\n        ? {\n            additionalLogRecordProcessors:\n              opts._internalAdditionalLogRecordProcessors,\n          }\n        : {}),\n      ...(opts._internalAdditionalMetricReaders\n        ? {\n            additionalMetricReaders: opts._internalAdditionalMetricReaders,\n          }\n        : {}),\n    });\n  }\n\n  await fetchRemoteConfig(targets.config, fetcher, runtime);\n\n  // Service-worker registration is best-effort and never blocks\n  // kernel resolution. The SW intercepts `/api/interfere/*` POSTs\n  // from the page and queues failures in IndexedDB so OTel batches\n  // survive page-hide / offline / >30s collector blips. See\n  // `internal/sw.ts`.\n  registerServiceWorker({\n    onMessage: (msg) => recordSwMessage(kernel, msg),\n  }).catch(() => {\n    // registerServiceWorker is best-effort and swallows its own\n    // failures; this catch is just to satisfy biome's no-floating-\n    // promise rule without using `void`.\n  });\n\n  return kernel;\n}\n\nfunction recordSwMessage(\n  kernel: { recordLog: Kernel[\"recordLog\"] },\n  msg: SwMessage\n): void {\n  // SW activity rides as INFO LogRecords so dashboards can rank\n  // queued vs replayed vs dropped without a new metric surface. The\n  // SW runs in its own context — we only see what gets posted back\n  // when a page is open, which is fine: \"did the SW catch anything\"\n  // is the question dashboards need to answer.\n  kernel.recordLog({\n    severityText: \"info\",\n    severityNumber: 9,\n    body: msg.type,\n    attributes: {\n      \"url.full\": msg.url,\n      ...(msg.reason ? { \"interfere.sw.reason\": msg.reason } : {}),\n    },\n  });\n}\n\n/**\n * Lazy-imports the OTel module so `init({ tracing: false })` keeps the\n * error-only bundle path light — the dynamic `import()` is what tells the\n * bundler to code-split. Inherits the kernel's resolved auth headers so\n * OTLP exports use the same collector URL and headers the rest of the SDK\n * resolved; no separate auth knob.\n *\n * Module-load failures are NOT caught — a bundled dynamic import only\n * fails on OOM or module-federation split-brain, both real problems we\n * want to surface, not silently flip into \"tracing disabled.\"\n */\ninterface ResolvedTracingOptions extends TracingOptions {\n  additionalLogRecordProcessors?: LogRecordProcessor[];\n  additionalMetricReaders?: MetricReader[];\n  additionalSpanProcessors?: SpanProcessor[];\n  serviceName?: string;\n}\n\nasync function wireOtel(\n  kernel: Kernel,\n  targets: {\n    collectorBaseUrl: string;\n    config: IngestTarget;\n    ingest: AuthHeaders;\n    session: IngestTarget;\n  },\n  wrapperVersions: string[] | undefined,\n  tracing: ResolvedTracingOptions\n): Promise<void> {\n  const {\n    buildOtelProvider,\n    captureWebVitals,\n    readPropagationFromDocument,\n    registerBundledInstrumentations,\n  } = await import(\"./otel/index.js\");\n\n  const collectorUrl = targets.collectorBaseUrl.replace(TRAILING_SLASH_RE, \"\");\n  const releaseSlug = readReleaseSlugFromGlobals();\n\n  const handle = buildOtelProvider({\n    collectorUrl,\n    authHeaders: targets.ingest.headers,\n    sdkStack: buildSdkStack(wrapperVersions),\n    // Session id is read per-span by the session span processor, so a\n    // mid-page session rotation is reflected on subsequent spans\n    // without rebuilding the provider.\n    getSessionId: () => kernel.session.getId(),\n    // `device.id` is stable for the page lifetime — `DeviceManager.init()`\n    // ran during `createKernel` before this point, so the id is in\n    // localStorage / cookie / memory by the time the provider boots.\n    // Stamped as a resource attribute so every span / log / metric\n    // carries it without per-record re-stamping; the collector projects\n    // it into `spans.deviceId`. Without this the column is permanently\n    // null in production (which is exactly what we observed in\n    // 2026-05-12 telemetry — 0/50,632 spans had a device id).\n    deviceId: kernel.device.getDeviceId(),\n    releaseSlug,\n    ...(tracing.serviceName ? { serviceName: tracing.serviceName } : {}),\n    ...(tracing.additionalSpanProcessors\n      ? { additionalSpanProcessors: tracing.additionalSpanProcessors }\n      : {}),\n    ...(tracing.additionalLogRecordProcessors\n      ? {\n          additionalLogRecordProcessors: tracing.additionalLogRecordProcessors,\n        }\n      : {}),\n    ...(tracing.additionalMetricReaders\n      ? { additionalMetricReaders: tracing.additionalMetricReaders }\n      : {}),\n  });\n\n  // Phase 4: stitch the client trace onto whatever the SSR renderer was\n  // already in. SSR injects a `traceparent` meta tag; we extract it into a\n  // Context and seed the page-scope context manager with it. Spans created\n  // outside any zone (DocumentLoad, Fetch listeners attached by OTel\n  // instrumentations, app code in `useEffect`) fall back to that context\n  // and become children of the server-side parent. No meta tag → page\n  // scope stays at ROOT_CONTEXT; spans default to fresh roots.\n  const extracted = readPropagationFromDocument();\n  if (extracted) {\n    handle.contextManager.setPageScope(extracted);\n  }\n\n  const dispose = registerBundledInstrumentations({\n    tracerProvider: handle.tracerProvider,\n    // Skip auto-instrumenting every fetch the SDK itself makes.\n    // Without this we trace OTLP sink POSTs (infinite loop) and the\n    // SDK's own config / session-sync requests — and worse, those\n    // self-fetches' transient failures (DOMException timeouts on\n    // flaky networks, ECONNRESET on the homepage's outbound\n    // collector calls) get recorded as `exception` events and end up\n    // in `events_pending`, burning enrichment cycles on\n    // pipeline-internal noise that has nothing to do with the\n    // customer's app. Measured 2026-05-12: 100% of `events_pending`\n    // exceptions were children of `fetch GET …/v2/config` / `…/v2/sink`\n    // spans.\n    //\n    // Exact-string ignore on the resolved target URLs (set at SDK\n    // boot from `resolveTargets`) so customer proxies on\n    // `/api/interfere/v2/*` are caught too. The OTLP sink lives at\n    // `${collectorBaseUrl}/v2/sink` (`COLLECTOR_SINK_PATH` in the\n    // exporter); config and session land on full URLs already.\n    ignoreUrls: [\n      `${collectorUrl}/v2/sink`,\n      targets.config.url,\n      targets.session.url,\n    ],\n    ...(tracing.propagateContextUrls\n      ? { propagateContextUrls: tracing.propagateContextUrls }\n      : {}),\n    ...(tracing.resolveRoute ? { resolveRoute: tracing.resolveRoute } : {}),\n  });\n\n  if (tracing.webVitals !== false) {\n    captureWebVitals({\n      meter: handle.meterProvider.getMeter(\"@interfere/react/web-vitals\"),\n      flush: () => handle.flush(),\n      ...(tracing.resolveRoute ? { resolveRoute: tracing.resolveRoute } : {}),\n    });\n  }\n\n  kernel.attachOtel(handle, dispose);\n}\n\nasync function fetchRemoteConfig(\n  configTarget: IngestTarget,\n  fetcher: typeof globalThis.fetch,\n  runtime: PluginRuntime\n): Promise<void> {\n  try {\n    const headers = Object.fromEntries(configTarget.headers.entries());\n    const res = await fetcher(configTarget.url, {\n      method: \"GET\",\n      headers,\n      signal: AbortSignal.timeout(10_000),\n    });\n    if (!res.ok) {\n      return;\n    }\n    const config = (await res.json()) as RemoteConfig;\n    if (config?.plugins) {\n      runtime.applyRemoteConfig(config.plugins);\n      log.debug(\"applied remote config\");\n    }\n  } catch {\n    log.warn(\"remote config fetch failed, using local defaults\");\n  }\n}\n\nexport function isEnabledByEnvironment(): boolean {\n  if (typeof process === \"undefined\" || !process.env) {\n    return true;\n  }\n  const nodeEnv = process.env[\"NODE_ENV\"];\n  if (nodeEnv === \"production\" || nodeEnv === undefined) {\n    return true;\n  }\n  return !!(\n    getGlobal<boolean>(\"__INTERFERE_FORCE_ENABLE__\") ||\n    process.env[\"INTERFERE_FORCE_ENABLE\"]\n  );\n}\n\n/**\n * Build-time-derived release slug. The build step\n * (`@interfere/next/withInterfere`, `@interfere/vite/plugin`) takes the\n * leading 16 hex chars of the commit SHA (`rel_<16hex>`) and stamps it into\n * the bundle as `__INTERFERE_RELEASE_SLUG__`. The collector derives the same\n * value from the create-release request, so the bundle's runtime slug is\n * guaranteed to match the row without a round-trip.\n *\n * Returns `null` when no slug was injected (dev builds, customers who\n * haven't wired up the plugin).\n */\nexport function readReleaseSlugFromGlobals(): ReleaseSlug | null {\n  const value = getGlobal<unknown>(\"__INTERFERE_RELEASE_SLUG__\");\n\n  return typeof value === \"string\" ? releaseSlugSchema.parse(value) : null;\n}\n"],"mappings":"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"}

package/dist/internal/otel/exporter.d.mts

@@ -0,0 +1,85 @@
+import { ExportResult } from "@opentelemetry/core";
+import { AggregationTemporality, PushMetricExporter, ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
+
+//#region src/internal/otel/exporter.d.ts
+interface ExporterCommon {
+  /**
+   * Kept for wrapper compatibility. Public-key identity is baked into
+   * `collectorUrl` as a `pk` query parameter before exporters are built.
+   */
+  authHeaders: Headers;
+  /** Base collector URL — the opaque sink path is appended. */
+  collectorUrl: string;
+}
+/** Exported for direct unit testing. */
+declare function buildSinkUrl(collectorUrl: string): string;
+/**
+ * Beacon-flavoured sink URL — encodes the producer-version (always)
+ * while preserving the `pk` query already baked into `collectorUrl`.
+ *
+ * Exported for direct unit testing.
+ */
+declare function buildBeaconUrl(input: ExporterCommon): string;
+/**
+ * Browser-side OTLP trace exporter.
+ *
+ * Dispatches every export via `navigator.sendBeacon` — which is the
+ * only browser transport that reliably commits a request the page is
+ * also tearing down (`visibilitychange→hidden`, hard navigation). The
+ * `keepalive: true` fetch path the OTLP HTTP exporter ships with
+ * works for small payloads but falls back to ordinary fetch (which
+ * the renderer aborts on unload) once the cumulative 64KiB / 9-
+ * concurrent budget is exhausted. Production data on 2026-05-11
+ * attributed ~15% browser-fetch span loss to that fallback; the
+ * beacon path closes that hole by design.
+ *
+ * Identity rides the URL because beacons can't carry custom headers.
+ *
+ * No retry on failure. The service worker backstop captures 5xx /
+ * network failures separately by intercepting the same beacon POST
+ * and queueing into IndexedDB for replay (`internal/sw.ts`).
+ */
+declare class BeaconTraceExporter implements SpanExporter {
+  private readonly url;
+  constructor(url: string);
+  export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+/**
+ * Browser-side OTLP log exporter — same beacon transport, log
+ * payload. See `BeaconTraceExporter` for the design rationale.
+ */
+declare class BeaconLogExporter {
+  private readonly url;
+  constructor(url: string);
+  export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+/**
+ * Browser-side OTLP metric exporter — beacon transport, metric
+ * payload, `DELTA` temporality.
+ *
+ * `DELTA` matches what the OTLP HTTP exporter the kit's previous
+ * `OTLPMetricExporter` was configured with (see the
+ * `temporalityPreference: AggregationTemporalityPreference.DELTA`
+ * arg `provider.ts` used to pass). Returning the same temporality
+ * for every instrument type keeps the wire shape downstream
+ * consumers receive unchanged across the migration.
+ */
+declare class BeaconMetricExporter implements PushMetricExporter {
+  private readonly url;
+  constructor(url: string);
+  export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+  selectAggregationTemporality(): AggregationTemporality;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+declare function createBeaconTraceExporter(input: ExporterCommon): BeaconTraceExporter;
+declare function createBeaconMetricExporter(input: ExporterCommon): BeaconMetricExporter;
+declare function createBeaconLogExporter(input: ExporterCommon): BeaconLogExporter;
+//#endregion
+export { buildBeaconUrl, buildSinkUrl, createBeaconLogExporter, createBeaconMetricExporter, createBeaconTraceExporter };

package/dist/internal/otel/exporter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter.d.mts","names":[],"sources":["../../../src/internal/otel/exporter.ts"],"mappings":";;;;;;UA0EU,cAAA;EAAA;;;;EAKR,WAAA,EAAa,OAAO;EAAP;EAEb,YAAA;AAAA;AAAY;AAAA,iBAIE,YAAA,CAAa,YAAoB;;;;AAAA;AAUjD;;iBAAgB,cAAA,CAAe,KAAqB,EAAd,cAAc;;AAAA;AAMnD;;;;;;;;;;;;;;;;;cAoGK,mBAAA,YAA+B,YAAA;EAAA,iBAClB,GAAA;cAEL,GAAA;EAIZ,MAAA,CACE,KAAA,EAAO,YAAA,IACP,cAAA,GAAiB,MAAA,EAAQ,YAAA;EAc3B,QAAA,CAAA,GAAY,OAAA;EAIZ,UAAA,CAAA,GAAc,OAAA;AAAA;;AAAO;AAAA;;cASjB,iBAAA;EAAA,iBACa,GAAA;cAEL,GAAA;EAIZ,MAAA,CACE,IAAA,EAAM,iBAAA,IACN,cAAA,GAAiB,MAAA,EAAQ,YAAA;EAc3B,QAAA,CAAA,GAAY,OAAA;EAIZ,UAAA,CAAA,GAAc,OAAA;AAAA;;;;;;;;;;;;cAgBV,oBAAA,YAAgC,kBAAA;EAAA,iBACnB,GAAA;cAEL,GAAA;EAIZ,MAAA,CACE,OAAA,EAAS,eAAA,EACT,cAAA,GAAiB,MAAA,EAAQ,YAAA;EAU3B,4BAAA,CAAA,GAAgC,sBAAA;EAIhC,UAAA,CAAA,GAAc,OAAA;EAId,QAAA,CAAA,GAAY,OAAA;AAAA;AAAA,iBAKE,yBAAA,CACd,KAAA,EAAO,cAAA,GACN,mBAAmB;AAAA,iBAIN,0BAAA,CACd,KAAA,EAAO,cAAA,GACN,oBAAoB;AAAA,iBAIP,uBAAA,CACd,KAAA,EAAO,cAAA,GACN,iBAAiB"}

package/dist/internal/otel/exporter.mjs

@@ -0,0 +1 @@
+import{appendPathBeforeQuery,withQueryParam}from"../config.mjs";import{PRODUCER_VERSION}from"../version.mjs";import{diag}from"@opentelemetry/api";import{ExportResultCode}from"@opentelemetry/core";import{JsonLogsSerializer}from"@opentelemetry/otlp-transformer/build/esm/logs/json/logs.js";import{JsonMetricsSerializer}from"@opentelemetry/otlp-transformer/build/esm/metrics/json/metrics.js";import{JsonTraceSerializer}from"@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js";import{AggregationTemporality}from"@opentelemetry/sdk-metrics";function buildSinkUrl(collectorUrl){return appendPathBeforeQuery(collectorUrl,`/v2/sink`)}function buildBeaconUrl(input){return withQueryParam(buildSinkUrl(input.collectorUrl),`_pv`,PRODUCER_VERSION)}function canSendBeacon(){return typeof navigator<`u`&&typeof navigator.sendBeacon==`function`}function reportBeacon(url,payload,signal,resultCallback){if(!payload||payload.byteLength===0){diag.debug(`[interfere/beacon] ${signal} serializer returned no bytes`),resultCallback({code:ExportResultCode.SUCCESS});return}if(!canSendBeacon()){diag.debug(`[interfere/beacon] navigator.sendBeacon unavailable; dropping ${signal} batch (${payload.byteLength}B)`),resultCallback({code:ExportResultCode.SUCCESS});return}let blob=new Blob([payload],{type:`application/json`});navigator.sendBeacon(url,blob)||diag.debug(`[interfere/beacon] navigator.sendBeacon refused ${signal} payload (oversized or queue full); dropping ${payload.byteLength}B`),resultCallback({code:ExportResultCode.SUCCESS})}var BeaconTraceExporter=class{url;constructor(url){this.url=url}export(spans,resultCallback){if(spans.length===0){resultCallback({code:ExportResultCode.SUCCESS});return}reportBeacon(this.url,JsonTraceSerializer.serializeRequest(spans),`trace`,resultCallback)}shutdown(){return Promise.resolve()}forceFlush(){return Promise.resolve()}},BeaconLogExporter=class{url;constructor(url){this.url=url}export(logs,resultCallback){if(logs.length===0){resultCallback({code:ExportResultCode.SUCCESS});return}reportBeacon(this.url,JsonLogsSerializer.serializeRequest(logs),`log`,resultCallback)}shutdown(){return Promise.resolve()}forceFlush(){return Promise.resolve()}},BeaconMetricExporter=class{url;constructor(url){this.url=url}export(metrics,resultCallback){reportBeacon(this.url,JsonMetricsSerializer.serializeRequest(metrics),`metric`,resultCallback)}selectAggregationTemporality(){return AggregationTemporality.DELTA}forceFlush(){return Promise.resolve()}shutdown(){return Promise.resolve()}};function createBeaconTraceExporter(input){return new BeaconTraceExporter(buildBeaconUrl(input))}function createBeaconMetricExporter(input){return new BeaconMetricExporter(buildBeaconUrl(input))}function createBeaconLogExporter(input){return new BeaconLogExporter(buildBeaconUrl(input))}export{buildBeaconUrl,buildSinkUrl,createBeaconLogExporter,createBeaconMetricExporter,createBeaconTraceExporter};

package/dist/internal/otel/exporter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter.mjs","names":[],"sources":["../../../src/internal/otel/exporter.ts"],"sourcesContent":["import { diag } from \"@opentelemetry/api\";\nimport type { ExportResult } from \"@opentelemetry/core\";\nimport { ExportResultCode } from \"@opentelemetry/core\";\n// Deep imports against the package build output — the barrel\n// (`@opentelemetry/otlp-transformer`) re-exports the JSON *and*\n// Protobuf serializers, and the protobuf side reaches `protobufjs`\n// which transitively hits `worker_threads.MessageChannel` (via\n// `import-in-the-middle`). Vite externalizes `worker_threads` for\n// the browser test environment with a runtime-throwing stub; the\n// kernel's `await import(\"./otel/index.js\")` chunk inherits any file\n// reachable from the package root through Vite's dep optimizer, so\n// importing from the barrel breaks `provider.test.tsx` with\n// \"Failed to fetch dynamically imported module\" on the chunk URL.\n//\n// The `*/json/trace.js` (etc.) modules import only `@opentelemetry/\n// api` and the package's own JSON-only utility files — no protobuf\n// in the transitive graph. We also pin the file extension (`.js`)\n// instead of letting the directory's `index.js` resolution kick in\n// because resolvers (bun on Linux vs macOS, vite vs raw esbuild)\n// disagree about whether a missing extension on a directory-shaped\n// specifier should resolve to `<dir>/index.js` or fail. The explicit\n// `.js` is the only spelling all of them agree on.\n//\n// `@opentelemetry/otlp-transformer` doesn't ship an `\"exports\"` field\n// in its `package.json`, so these deep paths are the supported escape\n// hatch (the OTel HTTP exporters take the same approach internally —\n// see `@opentelemetry/exporter-trace-otlp-http/build/esm/platform/\n// browser/OTLPTraceExporter.js`). Pinned via the workspace catalog so\n// a minor version bump can't quietly relocate the build directory.\nimport { JsonLogsSerializer } from \"@opentelemetry/otlp-transformer/build/esm/logs/json/logs.js\";\nimport { JsonMetricsSerializer } from \"@opentelemetry/otlp-transformer/build/esm/metrics/json/metrics.js\";\nimport { JsonTraceSerializer } from \"@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js\";\nimport type { ReadableLogRecord } from \"@opentelemetry/sdk-logs\";\nimport type {\n  PushMetricExporter,\n  ResourceMetrics,\n} from \"@opentelemetry/sdk-metrics\";\nimport { AggregationTemporality } from \"@opentelemetry/sdk-metrics\";\nimport type { ReadableSpan, SpanExporter } from \"@opentelemetry/sdk-trace-base\";\n\nimport { appendPathBeforeQuery, withQueryParam } from \"../config.js\";\nimport { PRODUCER_VERSION } from \"../version.js\";\n\n/**\n * Opaque collector ingest path. Single endpoint for every OTLP signal —\n * server-side dispatches by which `resource*` block the request carries.\n *\n * Semantically nondescript so common adblock filter lists (EasyPrivacy,\n * uBlock) don't fingerprint it the way they do `traces` / `metrics` /\n * `logs` / `telemetry`. Customer-domain proxy mode is still the\n * recommended path for browser SDKs; this is the second line of defence\n * for direct-ingestion clients.\n */\nconst COLLECTOR_SINK_PATH = \"/v2/sink\";\n\n/**\n * Identity gate values the collector accepts via URL query when their\n * matching headers can't be set.\n *\n * `navigator.sendBeacon` (the only browser transport that survives\n * `visibilitychange→hidden`) only attaches `Content-Type` via the\n * `Blob` — no other request headers. We rely on that exclusively for\n * the browser SDK's primary path, so the identity gates the collector\n * enforces have to ride the URL instead.\n *\n * Public-key query exposure note: public keys ship in browser bundles\n * and are visible in DevTools by design, so URL exposure is no worse\n * than the existing header path. API keys deliberately have **no**\n * query fallback — see `surfaceAkAuth` for the matching server-side\n * rationale.\n */\nconst PRODUCER_VERSION_QUERY = \"_pv\";\n\nconst JSON_CONTENT_TYPE = \"application/json\";\ninterface ExporterCommon {\n  /**\n   * Kept for wrapper compatibility. Public-key identity is baked into\n   * `collectorUrl` as a `pk` query parameter before exporters are built.\n   */\n  authHeaders: Headers;\n  /** Base collector URL — the opaque sink path is appended. */\n  collectorUrl: string;\n}\n\n/** Exported for direct unit testing. */\nexport function buildSinkUrl(collectorUrl: string): string {\n  return appendPathBeforeQuery(collectorUrl, COLLECTOR_SINK_PATH);\n}\n\n/**\n * Beacon-flavoured sink URL — encodes the producer-version (always)\n * while preserving the `pk` query already baked into `collectorUrl`.\n *\n * Exported for direct unit testing.\n */\nexport function buildBeaconUrl(input: ExporterCommon): string {\n  return withQueryParam(\n    buildSinkUrl(input.collectorUrl),\n    PRODUCER_VERSION_QUERY,\n    PRODUCER_VERSION\n  );\n}\n\n/**\n * Returns true iff the runtime can dispatch a `navigator.sendBeacon`\n * call. Browser-only; server contexts (SSR, prerender, Vitest's `node`\n * environment) trip the typeof guards.\n */\nfunction canSendBeacon(): boolean {\n  return (\n    typeof navigator !== \"undefined\" &&\n    typeof navigator.sendBeacon === \"function\"\n  );\n}\n\n/**\n * Dispatches an OTLP payload via `navigator.sendBeacon` and always\n * reports `SUCCESS` to the BSP. `sendBeacon` is fire-and-forget by\n * spec — a `true` return only means \"the user agent accepted the\n * payload into its delivery queue\", not \"the server received it\".\n *\n * Why never report `FAILED`:\n *   - `BatchSpanProcessor._flushOneBatch` rejects its promise on\n *     `code !== SUCCESS`, and that rejection propagates up through\n *     `forceFlush()` / `shutdown()`. In production, that surfaces\n *     during Vercel function teardown (and other awaited unload\n *     paths) as an unhandled rejection. In tests, it surfaces as\n *     `provider.test.tsx > passes through useSession` — vitest's\n *     `afterEach(close)` awaits `kernel.dispose() → BSP.shutdown\n *     → _flushAll`, the rejection bubbles, and the test fails.\n *   - `sendBeacon`'s `false` return signals a *local* drop (per-call\n *     ~64KiB ceiling, per-page queue full, disallowed scheme). No\n *     network request was attempted, so the service-worker backstop\n *     in `internal/sw.ts` can't intercept it either. Retrying inside\n *     the exporter would just hit the same browser limit again.\n *\n * The data is gone, but the export *completed* in the only sense\n * that matters to the BSP. A `diag.debug` keeps visibility for any\n * OTel diag listener wired into the kernel.\n */\nfunction reportBeacon(\n  url: string,\n  payload: Uint8Array | undefined,\n  signal: \"trace\" | \"log\" | \"metric\",\n  resultCallback: (result: ExportResult) => void\n): void {\n  if (!payload || payload.byteLength === 0) {\n    diag.debug(`[interfere/beacon] ${signal} serializer returned no bytes`);\n    resultCallback({ code: ExportResultCode.SUCCESS });\n    return;\n  }\n  if (!canSendBeacon()) {\n    diag.debug(\n      `[interfere/beacon] navigator.sendBeacon unavailable; dropping ${signal} batch (${payload.byteLength}B)`\n    );\n    resultCallback({ code: ExportResultCode.SUCCESS });\n    return;\n  }\n  // `Blob` is the only sendBeacon argument shape that lets us pin\n  // `Content-Type: application/json` on the request — using the raw\n  // `Uint8Array` would default to `application/octet-stream`, which\n  // the collector's content-type allowlist rejects with 415.\n  //\n  // The cast is necessary because `JsonTraceSerializer.serializeRequest`\n  // returns `Uint8Array<ArrayBufferLike>`, but `Blob`'s constructor\n  // narrows `BlobPart` to `Uint8Array<ArrayBuffer>` (excluding\n  // `SharedArrayBuffer`). The serializer never returns shared-buffer-\n  // backed bytes (it allocates a fresh `Uint8Array(byteLength)`\n  // internally) so the runtime check the type system is asking for is\n  // already true; a structural cast preserves that without forcing an\n  // unnecessary buffer copy.\n  const blob = new Blob([payload as Uint8Array<ArrayBuffer>], {\n    type: JSON_CONTENT_TYPE,\n  });\n  if (!navigator.sendBeacon(url, blob)) {\n    diag.debug(\n      `[interfere/beacon] navigator.sendBeacon refused ${signal} payload (oversized or queue full); dropping ${payload.byteLength}B`\n    );\n  }\n  resultCallback({ code: ExportResultCode.SUCCESS });\n}\n\n/**\n * Browser-side OTLP trace exporter.\n *\n * Dispatches every export via `navigator.sendBeacon` — which is the\n * only browser transport that reliably commits a request the page is\n * also tearing down (`visibilitychange→hidden`, hard navigation). The\n * `keepalive: true` fetch path the OTLP HTTP exporter ships with\n * works for small payloads but falls back to ordinary fetch (which\n * the renderer aborts on unload) once the cumulative 64KiB / 9-\n * concurrent budget is exhausted. Production data on 2026-05-11\n * attributed ~15% browser-fetch span loss to that fallback; the\n * beacon path closes that hole by design.\n *\n * Identity rides the URL because beacons can't carry custom headers.\n *\n * No retry on failure. The service worker backstop captures 5xx /\n * network failures separately by intercepting the same beacon POST\n * and queueing into IndexedDB for replay (`internal/sw.ts`).\n */\nclass BeaconTraceExporter implements SpanExporter {\n  private readonly url: string;\n\n  constructor(url: string) {\n    this.url = url;\n  }\n\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    if (spans.length === 0) {\n      resultCallback({ code: ExportResultCode.SUCCESS });\n      return;\n    }\n    reportBeacon(\n      this.url,\n      JsonTraceSerializer.serializeRequest(spans),\n      \"trace\",\n      resultCallback\n    );\n  }\n\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n\n/**\n * Browser-side OTLP log exporter — same beacon transport, log\n * payload. See `BeaconTraceExporter` for the design rationale.\n */\nclass BeaconLogExporter {\n  private readonly url: string;\n\n  constructor(url: string) {\n    this.url = url;\n  }\n\n  export(\n    logs: ReadableLogRecord[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    if (logs.length === 0) {\n      resultCallback({ code: ExportResultCode.SUCCESS });\n      return;\n    }\n    reportBeacon(\n      this.url,\n      JsonLogsSerializer.serializeRequest(logs),\n      \"log\",\n      resultCallback\n    );\n  }\n\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n\n/**\n * Browser-side OTLP metric exporter — beacon transport, metric\n * payload, `DELTA` temporality.\n *\n * `DELTA` matches what the OTLP HTTP exporter the kit's previous\n * `OTLPMetricExporter` was configured with (see the\n * `temporalityPreference: AggregationTemporalityPreference.DELTA`\n * arg `provider.ts` used to pass). Returning the same temporality\n * for every instrument type keeps the wire shape downstream\n * consumers receive unchanged across the migration.\n */\nclass BeaconMetricExporter implements PushMetricExporter {\n  private readonly url: string;\n\n  constructor(url: string) {\n    this.url = url;\n  }\n\n  export(\n    metrics: ResourceMetrics,\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    reportBeacon(\n      this.url,\n      JsonMetricsSerializer.serializeRequest(metrics),\n      \"metric\",\n      resultCallback\n    );\n  }\n\n  selectAggregationTemporality(): AggregationTemporality {\n    return AggregationTemporality.DELTA;\n  }\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n\nexport function createBeaconTraceExporter(\n  input: ExporterCommon\n): BeaconTraceExporter {\n  return new BeaconTraceExporter(buildBeaconUrl(input));\n}\n\nexport function createBeaconMetricExporter(\n  input: ExporterCommon\n): BeaconMetricExporter {\n  return new BeaconMetricExporter(buildBeaconUrl(input));\n}\n\nexport function createBeaconLogExporter(\n  input: ExporterCommon\n): BeaconLogExporter {\n  return new BeaconLogExporter(buildBeaconUrl(input));\n}\n"],"mappings":"miBAqFA,SAAgB,aAAa,aAA8B,CACzD,OAAO,sBAAsB,aAAc,UAAmB,CAChE,CAQA,SAAgB,eAAe,MAA+B,CAC5D,OAAO,eACL,aAAa,MAAM,YAAY,EAC/B,MACA,gBACF,CACF,CAOA,SAAS,eAAyB,CAChC,OACE,OAAO,UAAc,KACrB,OAAO,UAAU,YAAe,UAEpC,CA2BA,SAAS,aACP,IACA,QACA,OACA,eACM,CACN,GAAI,CAAC,SAAW,QAAQ,aAAe,EAAG,CACxC,KAAK,MAAM,sBAAsB,OAAO,8BAA8B,EACtE,eAAe,CAAE,KAAM,iBAAiB,OAAQ,CAAC,EACjD,MACF,CACA,GAAI,CAAC,cAAc,EAAG,CACpB,KAAK,MACH,iEAAiE,OAAO,UAAU,QAAQ,WAAW,GACvG,EACA,eAAe,CAAE,KAAM,iBAAiB,OAAQ,CAAC,EACjD,MACF,CAcA,IAAM,KAAO,IAAI,KAAK,CAAC,OAAkC,EAAG,CAC1D,KAAM,kBACR,CAAC,EACI,UAAU,WAAW,IAAK,IAAI,GACjC,KAAK,MACH,mDAAmD,OAAO,+CAA+C,QAAQ,WAAW,EAC9H,EAEF,eAAe,CAAE,KAAM,iBAAiB,OAAQ,CAAC,CACnD,CAqBA,IAAM,oBAAN,KAAkD,CAChD,IAEA,YAAY,IAAa,CACvB,KAAK,IAAM,GACb,CAEA,OACE,MACA,eACM,CACN,GAAI,MAAM,SAAW,EAAG,CACtB,eAAe,CAAE,KAAM,iBAAiB,OAAQ,CAAC,EACjD,MACF,CACA,aACE,KAAK,IACL,oBAAoB,iBAAiB,KAAK,EAC1C,QACA,cACF,CACF,CAEA,UAA0B,CACxB,OAAO,QAAQ,QAAQ,CACzB,CAEA,YAA4B,CAC1B,OAAO,QAAQ,QAAQ,CACzB,CACF,EAMM,kBAAN,KAAwB,CACtB,IAEA,YAAY,IAAa,CACvB,KAAK,IAAM,GACb,CAEA,OACE,KACA,eACM,CACN,GAAI,KAAK,SAAW,EAAG,CACrB,eAAe,CAAE,KAAM,iBAAiB,OAAQ,CAAC,EACjD,MACF,CACA,aACE,KAAK,IACL,mBAAmB,iBAAiB,IAAI,EACxC,MACA,cACF,CACF,CAEA,UAA0B,CACxB,OAAO,QAAQ,QAAQ,CACzB,CAEA,YAA4B,CAC1B,OAAO,QAAQ,QAAQ,CACzB,CACF,EAaM,qBAAN,KAAyD,CACvD,IAEA,YAAY,IAAa,CACvB,KAAK,IAAM,GACb,CAEA,OACE,QACA,eACM,CACN,aACE,KAAK,IACL,sBAAsB,iBAAiB,OAAO,EAC9C,SACA,cACF,CACF,CAEA,8BAAuD,CACrD,OAAO,uBAAuB,KAChC,CAEA,YAA4B,CAC1B,OAAO,QAAQ,QAAQ,CACzB,CAEA,UAA0B,CACxB,OAAO,QAAQ,QAAQ,CACzB,CACF,EAEA,SAAgB,0BACd,MACqB,CACrB,OAAO,IAAI,oBAAoB,eAAe,KAAK,CAAC,CACtD,CAEA,SAAgB,2BACd,MACsB,CACtB,OAAO,IAAI,qBAAqB,eAAe,KAAK,CAAC,CACvD,CAEA,SAAgB,wBACd,MACmB,CACnB,OAAO,IAAI,kBAAkB,eAAe,KAAK,CAAC,CACpD"}

package/dist/internal/otel/index.d.mts

@@ -0,0 +1,6 @@
+import { createBeaconMetricExporter, createBeaconTraceExporter } from "./exporter.mjs";
+import { InstrumentationsInput, registerBundledInstrumentations } from "./instrumentations.mjs";
+import { readPropagationFromDocument } from "./propagation.mjs";
+import { OtelProviderHandle, OtelProviderInput, buildOtelProvider } from "./provider.mjs";
+import { captureWebVitals } from "./web-vitals.mjs";
+export { type InstrumentationsInput, type OtelProviderHandle, type OtelProviderInput, buildOtelProvider, captureWebVitals, createBeaconMetricExporter, createBeaconTraceExporter, readPropagationFromDocument, registerBundledInstrumentations };

package/dist/internal/otel/index.mjs

@@ -0,0 +1 @@
+import{createBeaconMetricExporter,createBeaconTraceExporter}from"./exporter.mjs";import{registerBundledInstrumentations}from"./instrumentations.mjs";import{readPropagationFromDocument}from"./propagation.mjs";import{buildOtelProvider}from"./provider.mjs";import{captureWebVitals}from"./web-vitals.mjs";export{buildOtelProvider,captureWebVitals,createBeaconMetricExporter,createBeaconTraceExporter,readPropagationFromDocument,registerBundledInstrumentations};

package/dist/internal/otel/instrumentations.d.mts

@@ -0,0 +1,42 @@
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+
+//#region src/internal/otel/instrumentations.d.ts
+interface InstrumentationsInput {
+  /**
+   * 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)[];
+  /**
+   * 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;
+}
+/**
+ * Registers every browser auto-instrumentation 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.
+ *
+ * Returns a disposer that unregisters everything; called by
+ * `kernel.dispose()`.
+ */
+declare function registerBundledInstrumentations(input: InstrumentationsInput): () => void;
+//#endregion
+export { InstrumentationsInput, registerBundledInstrumentations };

package/dist/internal/otel/instrumentations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentations.d.mts","names":[],"sources":["../../../src/internal/otel/instrumentations.ts"],"mappings":";;;UAgHiB,qBAAA;;AAAjB;;;;;EAOE,UAAA,YAAsB,MAAA;EAiBW;;;;;EAXjC,oBAAA,aAAiC,MAAA;EAMjC;;;;;EAAA,YAAA,IAAgB,QAAA;EAkBF;;;;EAbd,cAAA,EAAgB,iBAAA;AAAA;;;;;;;;;;;iBAaF,+BAAA,CACd,KAA4B,EAArB,qBAAqB"}

package/dist/internal/otel/instrumentations.mjs

@@ -0,0 +1 @@
+import{describeActionable,isActionable}from"../dom/actionable.mjs";import{registerInstrumentations}from"@opentelemetry/instrumentation";import{BrowserNavigationInstrumentation,defaultSanitizeUrl}from"@opentelemetry/instrumentation-browser-navigation";import{DocumentLoadInstrumentation}from"@opentelemetry/instrumentation-document-load";import{FetchInstrumentation}from"@opentelemetry/instrumentation-fetch";import{LongTaskInstrumentation}from"@opentelemetry/instrumentation-long-task";import{UserInteractionInstrumentation}from"@opentelemetry/instrumentation-user-interaction";import{XMLHttpRequestInstrumentation}from"@opentelemetry/instrumentation-xml-http-request";const ATTR_HTTP_ROUTE=`http.route`,ATTR_URL_FULL=`url.full`,ATTR_URL_PATH=`url.path`,SEMCONV_STABILITY_OPT_IN=`http,database,messaging,gen_ai_latest_experimental`,THIRD_PARTY_IGNORE=[/(?:^|\/\/)clerk\./,/\.clerk\./,/\.sentry\./,/\.intercom\./,/\.posthog\./,/\.googletagmanager\.com/,/\.google-analytics\.com/,/\.googleapis\.com/,/\.doubleclick\.net/,/\.facebook\.com/,/\.fbcdn\.net/,/\.analytics\.google\.com/,/px\.ads\.linkedin\.com/,/[?&]_rsc=/],NEVER_MATCH=/^$/,ESCAPE_RE=/[.*+?^${}()|[\]\\]/g;function sameOriginPattern(){if(typeof window>`u`)return NEVER_MATCH;let{protocol,host}=window.location;return RegExp(`^${protocol}//${host.replace(ESCAPE_RE,`\\$&`)}`)}function stampInteractionAttrs(eventType,element,span){let desc=describeActionable(element);span.setAttribute(`ui.event_type`,eventType),span.setAttribute(`ui.target.tag`,desc.tag),desc.id&&span.setAttribute(`ui.target.id`,desc.id),desc.name&&span.setAttribute(`ui.target.name`,desc.name),desc.role&&span.setAttribute(`ui.target.role`,desc.role),desc.ariaLabel&&span.setAttribute(`ui.target.aria_label`,desc.ariaLabel),desc.text&&span.setAttribute(`ui.target.text`,desc.text)}function stampUrlAttrs(span,resolveRoute){if(typeof window>`u`)return;let pathname=window.location.pathname,route=resolveRoute?.(pathname);span.setAttribute(ATTR_URL_PATH,route??pathname),span.setAttribute(ATTR_URL_FULL,window.location.href),route&&span.setAttribute(ATTR_HTTP_ROUTE,route)}function registerBundledInstrumentations(input){let{tracerProvider,ignoreUrls,propagateContextUrls=[]}=input,resolveRoute=input.resolveRoute,origin=sameOriginPattern(),fetchIgnore=[...ignoreUrls,...THIRD_PARTY_IGNORE];return registerInstrumentations({tracerProvider,instrumentations:[new FetchInstrumentation({propagateTraceHeaderCorsUrls:[origin,...propagateContextUrls],ignoreUrls:fetchIgnore,semconvStabilityOptIn:SEMCONV_STABILITY_OPT_IN,measureRequestSize:!0,applyCustomAttributesOnSpan:(span,request)=>{let url=request instanceof Request?request.url:request?.toString();if(typeof url==`string`)try{let parsed=new URL(url);if(span.setAttribute(ATTR_URL_PATH,parsed.pathname),origin.test(url)||propagateContextUrls.some(re=>re instanceof RegExp?re.test(url):url.includes(re))){let method=(request instanceof Request?request.method:void 0)??`GET`,route=resolveRoute?.(parsed.pathname);route&&span.setAttribute(ATTR_HTTP_ROUTE,route),span.updateName(`${method} ${route??parsed.pathname}`)}}catch{return}}}),new XMLHttpRequestInstrumentation({propagateTraceHeaderCorsUrls:[origin,...propagateContextUrls],ignoreUrls:fetchIgnore,semconvStabilityOptIn:SEMCONV_STABILITY_OPT_IN}),new DocumentLoadInstrumentation({semconvStabilityOptIn:SEMCONV_STABILITY_OPT_IN,applyCustomAttributesOnSpan:{resourceFetch:(span,entry)=>{let name=entry?.name;if(typeof name==`string`)try{let url=new URL(name),isCrossOrigin=typeof window<`u`&&url.origin!==window.location.origin;span.updateName(isCrossOrigin?`resource: ${url.host}${url.pathname}`:`resource: ${url.pathname}`),span.setAttribute(ATTR_URL_FULL,name),span.setAttribute(ATTR_URL_PATH,url.pathname),span.setAttribute(`server.address`,url.host)}catch{}}}}),new BrowserNavigationInstrumentation({sanitizeUrl:defaultSanitizeUrl}),new UserInteractionInstrumentation({eventNames:[`click`,`submit`],shouldPreventSpanCreation:(eventType,element,span)=>eventType===`click`&&!isActionable(element)?!0:(stampInteractionAttrs(eventType,element,span),stampUrlAttrs(span,resolveRoute),!1)}),new LongTaskInstrumentation({observerCallback:(span,info)=>{stampUrlAttrs(span,resolveRoute);let containerType=info.longtaskEntry.attribution[0]?.containerType;containerType&&span.setAttribute(`longtask.container_type`,containerType)}})]})}export{registerBundledInstrumentations};