@interfere/react 9.0.1 → 10.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"propagation.mjs","names":[],"sources":["../../../src/internal/otel/propagation.ts"],"sourcesContent":["import {\n  type Context,\n  defaultTextMapGetter,\n  ROOT_CONTEXT,\n  trace,\n} from \"@opentelemetry/api\";\nimport { W3CTraceContextPropagator } from \"@opentelemetry/core\";\n\nconst TRACEPARENT_META = \"traceparent\";\nconst TRACESTATE_META = \"tracestate\";\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\nconst TRACE_FLAGS_SAMPLED = 0x1;\n// Local instance — extraction must not depend on whether the customer (or\n// our own bootstrap) set a global propagator.\nconst W3C_PROPAGATOR = new W3CTraceContextPropagator();\n\nfunction readMeta(name: string): string | null {\n  if (typeof document === \"undefined\") {\n    return null;\n  }\n  const el = document.querySelector(`meta[name=\"${name}\"]`);\n  return el?.getAttribute(\"content\") ?? null;\n}\n\n/**\n * Reads the W3C `traceparent` (and optional `tracestate`) meta tag from the\n * document head and extracts an OTel `Context`. SSR renderers (Next, Vite,\n * …) inject the server-side request span's context so the client SDK can\n * stitch its spans onto the same trace.\n *\n * Returns `null` when:\n *  - called server-side (no `document`)\n *  - no `traceparent` meta tag is present\n *  - the extracted context has an invalid trace id\n *  - the `sampled` flag is unset — the browser doesn't honor the bit when\n *    creating child spans, so an unsampled parent would orphan every\n *    browser span under a trace with no recorded server segments. Drop\n *    instead so spans fall back to a fresh root.\n */\nexport function readPropagationFromDocument(): Context | null {\n  const traceparent = readMeta(TRACEPARENT_META);\n  if (!traceparent) {\n    return null;\n  }\n\n  const carrier: Record<string, string> = { traceparent };\n  const tracestate = readMeta(TRACESTATE_META);\n  if (tracestate) {\n    carrier[TRACESTATE_META] = tracestate;\n  }\n\n  const extracted = W3C_PROPAGATOR.extract(\n    ROOT_CONTEXT,\n    carrier,\n    defaultTextMapGetter\n  );\n  const spanCtx = trace.getSpanContext(extracted);\n  // octet of flag bits per the W3C trace-context spec; bit 0 is the sampled\n  // bit. Bitwise AND is the canonical extraction.\n  if (\n    !spanCtx ||\n    spanCtx.traceId === INVALID_TRACE_ID ||\n    // biome-ignore lint/suspicious/noBitwiseOperators: traceFlags is a single\n    (spanCtx.traceFlags & TRACE_FLAGS_SAMPLED) === 0\n  ) {\n    return null;\n  }\n  return extracted;\n}\n"],"mappings":";;;AAQA,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,mBAAmB;AACzB,MAAM,sBAAsB;AAG5B,MAAM,iBAAiB,IAAI,2BAA2B;AAEtD,SAAS,SAAS,MAA6B;CAC7C,IAAI,OAAO,aAAa,aACtB,OAAO;CAGT,OADW,SAAS,cAAc,cAAc,KAAK,IAC5C,EAAE,aAAa,UAAU,IAAI;;;;;;;;;;;;;;;;;AAkBxC,SAAgB,8BAA8C;CAC5D,MAAM,cAAc,SAAS,iBAAiB;CAC9C,IAAI,CAAC,aACH,OAAO;CAGT,MAAM,UAAkC,EAAE,aAAa;CACvD,MAAM,aAAa,SAAS,gBAAgB;CAC5C,IAAI,YACF,QAAQ,mBAAmB;CAG7B,MAAM,YAAY,eAAe,QAC/B,cACA,SACA,qBACD;CACD,MAAM,UAAU,MAAM,eAAe,UAAU;CAG/C,IACE,CAAC,WACD,QAAQ,YAAY,qBAEnB,QAAQ,aAAa,yBAAyB,GAE/C,OAAO;CAET,OAAO"}

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

@@ -0,0 +1,107 @@
+import { PageScopeContextManager } from "./page-scope-context-manager.mjs";
+import { ReleaseSlug } from "@interfere/types/releases/slug";
+import { MeterProvider, MetricReader } 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";
+import { SessionId } from "@interfere/types/data/session";
+
+//#region src/internal/otel/provider.d.ts
+interface OtelProviderInput {
+  /**
+   * @internal
+   *
+   * Extra log-record processors fanned into the LoggerProvider's
+   * processor list at construction. Used by `@interfere/observability`
+   * for internal-only dual-write to BetterStack — keeps a parallel
+   * destination's queue/exporter independent of the SDK's own.
+   * Customers don't get a fan-out hook on the SDK surface; this is a
+   * private bridge for our own dogfood apps.
+   */
+  additionalLogRecordProcessors?: LogRecordProcessor[];
+  /**
+   * @internal
+   *
+   * Extra metric readers fanned into the MeterProvider's reader list
+   * at construction. Used by `@interfere/observability` for internal-
+   * only dual-write of web vitals histograms (`web_vitals.{ttfb,fcp,
+   * lcp,inp,cls}`) to the BetterStack-fronting OTel collector. Each
+   * reader owns its own queue + exporter so a 5xx / network outage on
+   * the parallel destination backs off only its own batch.
+   */
+  additionalMetricReaders?: MetricReader[];
+  /**
+   * @internal
+   *
+   * Extra span processors fanned into the WebTracerProvider's processor
+   * list at construction. See `additionalLogRecordProcessors`.
+   */
+  additionalSpanProcessors?: SpanProcessor[];
+  /**
+   * Auth + content headers for OTLP exports. Sourced from the kernel's
+   * already-resolved ingest target so the OTLP path inherits the same
+   * `x-interfere-pub-token` (or proxy-mode auth) the rest of the SDK
+   * uses — no separate auth knob.
+   */
+  authHeaders: Headers;
+  /** OTLP base URL — the opaque sink path is appended by the exporters. */
+  collectorUrl: string;
+  /**
+   * Stable per-device identifier from `DeviceManager`. Resolved from
+   * localStorage / cookie at kernel boot, so it's synchronously
+   * available before the providers are constructed. Stamped as the
+   * OTel-semconv `device.id` resource attribute so every span / log /
+   * metric carries it without per-record re-stamping. Optional —
+   * tests and SSR boot paths that build the provider before the
+   * device manager has run pass `null`.
+   */
+  deviceId?: string | null | undefined;
+  /**
+   * 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;
+  /** 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 — never registers globally
+ * via `provider.register()` or `trace.setGlobalTracerProvider()`. Customers
+ * with their own OTel setup (DataDog, Vercel, etc.) cohabit cleanly.
+ *
+ * Splitting this out from `Kernel` keeps the OTel module lazy-loadable so
+ * the error-only bundle path (no tracing) never imports the OTel SDK.
+ */
+declare function buildOtelProvider(input: OtelProviderInput): OtelProviderHandle;
+//#endregion
+export { OtelProviderHandle, OtelProviderInput, buildOtelProvider };

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.mts","names":[],"sources":["../../../src/internal/otel/provider.ts"],"mappings":";;;;;;;;;UA0GiB,iBAAA;;AAAjB;;;;;;;;;EAWE,6BAAA,GAAgC,kBAAA;EA+CP;;;;;;;;;;EApCzB,uBAAA,GAA0B,YAAA;EAkC1B;;;;;;EA3BA,wBAAA,GAA2B,aAAA;EAwChB;AAGb;;;;;EApCE,WAAA,EAAa,OAAA;EA8CE;EA5Cf,YAAA;EA+CY;;;;;;;;;EArCZ,QAAA;EAkCA;;;;;;;EA1BA,YAAA,QAAoB,SAAA;EA8Ba;EA5BjC,WAAA,GAAc,WAAA;EAuCA;;;;;EAjCd,QAAA;EAmCC;;;;EA9BD,WAAA;AAAA;AAAA,UAGe,kBAAA;;;;;;EAMf,cAAA,EAAgB,uBAAA;;EAEhB,KAAA,IAAS,OAAA;EACT,cAAA,EAAgB,cAAA;EAChB,aAAA,EAAe,aAAA;EACf,YAAA,EAAc,YAAA;;EAEd,QAAA,IAAY,OAAA;EACZ,cAAA,EAAgB,iBAAA;AAAA;;;;;;;;;iBAWF,iBAAA,CACd,KAAA,EAAO,iBAAA,GACN,kBAAA"}

package/dist/internal/otel/provider.mjs

@@ -0,0 +1,151 @@
+import { SDK_NAME, SDK_VERSION } from "../version.mjs";
+import { createBeaconLogExporter, createBeaconMetricExporter, createBeaconTraceExporter } from "./exporter.mjs";
+import { PageScopeContextManager } from "./page-scope-context-manager.mjs";
+import { propagation } from "@opentelemetry/api";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { normalizeEnv } from "@interfere/types/sdk/runtime";
+import { browserDetector } from "@opentelemetry/opentelemetry-browser-detector";
+import { detectResources, resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import { createSessionLogRecordProcessor, createSessionSpanProcessor } from "@opentelemetry/web-common";
+//#region src/internal/otel/provider.ts
+const SERVICE_NAMESPACE = "interfere";
+const ATTR_SERVICE_NAME = "service.name";
+const ATTR_SERVICE_NAMESPACE = "service.namespace";
+const ATTR_DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name";
+const ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+const ATTR_RELEASE_SLUG = "release.slug";
+const ATTR_INTERFERE_SDK_STACK = "interfere.sdk.stack";
+const ATTR_INTERFERE_SDK_NAME = "interfere.sdk.name";
+const ATTR_INTERFERE_SDK_VERSION = "interfere.sdk.version";
+const ATTR_DEVICE_ID = "device.id";
+const DEFAULT_SERVICE_NAME = "interfere-sdk";
+/**
+* Tuned for `navigator.sendBeacon`'s per-call payload ceiling.
+*
+* The browser primary exporters dispatch every export via beacon
+* (see `BeaconTraceExporter` / `BeaconLogExporter` /
+* `BeaconMetricExporter` in `exporter.ts`) — sendBeacon is the only
+* browser transport that reliably commits a request the page is also
+* tearing down. It's not free though: most browsers cap each beacon
+* payload at 64KiB (Chrome / Firefox) and reject anything larger
+* with a `false` return from `navigator.sendBeacon` — at which point
+* the BSP just drops the batch (no retry: the SW backstop intercepts
+* 5xx / network failures, not user-agent rejections).
+*
+* The numbers below keep payloads comfortably under that ceiling,
+* even on jank-heavy pages (production data on 2026-05-11 saw 831
+* `longtask` spans piled up on a single page-hide, observed via the
+* BetterStack dual-write) where a 100-span batch would already top
+* 100KiB:
+*
+*   - `maxExportBatchSize: 10` — caps each beacon at ~10–20KiB,
+*     leaving headroom for span attribute bloat without flirting
+*     with the per-call ceiling.
+*   - `maxQueueSize: 50` — caps the worst-case unload payload at
+*     ~50–100KiB; the BSP drains across 5 beacons when forced-
+*     flushed on `visibilitychange→hidden`, all of which queue
+*     synchronously inside the user agent.
+*   - `scheduledDelayMillis: 2000` — quieter pages keep less in
+*     buffer at any moment, so a hidden→visible→hidden bounce
+*     doesn't accumulate 5s of telemetry waiting to ship.
+*   - `exportTimeoutMillis: 10_000` — unchanged. Beacon dispatches
+*     are essentially synchronous (the user agent enqueues into its
+*     own send loop), so the timeout is mostly defensive against
+*     pathological `JsonTraceSerializer.serializeRequest` calls.
+*/
+const BROWSER_BATCH_OPTIONS = {
+	maxQueueSize: 50,
+	maxExportBatchSize: 10,
+	scheduledDelayMillis: 2e3,
+	exportTimeoutMillis: 1e4
+};
+/**
+* Constructs the SDK's **private** OTel providers — never registers globally
+* via `provider.register()` or `trace.setGlobalTracerProvider()`. Customers
+* with their own OTel setup (DataDog, Vercel, etc.) cohabit cleanly.
+*
+* Splitting this out from `Kernel` keeps the OTel module lazy-loadable so
+* the error-only bundle path (no tracing) never imports the OTel SDK.
+*/
+function buildOtelProvider(input) {
+	const environment = normalizeEnv(typeof process === "undefined" ? void 0 : process.env["NODE_ENV"]) ?? "unknown";
+	const baseResource = resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: input.serviceName ?? DEFAULT_SERVICE_NAME,
+		[ATTR_SERVICE_NAMESPACE]: SERVICE_NAMESPACE,
+		[ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment,
+		[ATTR_TELEMETRY_SDK_LANGUAGE]: "webjs",
+		[ATTR_INTERFERE_SDK_NAME]: SDK_NAME,
+		[ATTR_INTERFERE_SDK_VERSION]: SDK_VERSION,
+		[ATTR_INTERFERE_SDK_STACK]: input.sdkStack.join(", "),
+		...input.releaseSlug ? { [ATTR_RELEASE_SLUG]: input.releaseSlug } : {},
+		...input.deviceId ? { [ATTR_DEVICE_ID]: input.deviceId } : {}
+	});
+	const detected = detectResources({ detectors: [browserDetector] });
+	const resource = baseResource.merge(detected);
+	const traceExporter = createBeaconTraceExporter({
+		collectorUrl: input.collectorUrl,
+		authHeaders: input.authHeaders
+	});
+	const getSessionId = input.getSessionId;
+	const tracerProvider = new WebTracerProvider({
+		resource,
+		spanProcessors: [
+			createSessionSpanProcessor({ getSessionId }),
+			new BatchSpanProcessor(traceExporter, BROWSER_BATCH_OPTIONS),
+			...input.additionalSpanProcessors ?? []
+		]
+	});
+	const contextManager = new PageScopeContextManager();
+	tracerProvider.register({ contextManager });
+	if (propagation.fields().length === 0) propagation.setGlobalPropagator(new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] }));
+	const metricReader = new PeriodicExportingMetricReader({
+		exporter: createBeaconMetricExporter({
+			collectorUrl: input.collectorUrl,
+			authHeaders: input.authHeaders
+		}),
+		exportIntervalMillis: 3e4
+	});
+	const meterProvider = new MeterProvider({
+		resource,
+		readers: [metricReader, ...input.additionalMetricReaders ?? []]
+	});
+	const logExporter = createBeaconLogExporter({
+		collectorUrl: input.collectorUrl,
+		authHeaders: input.authHeaders
+	});
+	const loggerProvider = new LoggerProvider({
+		resource,
+		processors: [
+			createSessionLogRecordProcessor({ getSessionId }),
+			new BatchLogRecordProcessor(logExporter, BROWSER_BATCH_OPTIONS),
+			...input.additionalLogRecordProcessors ?? []
+		]
+	});
+	return {
+		contextManager,
+		tracerProvider,
+		meterProvider,
+		metricReader,
+		loggerProvider,
+		flush: async () => {
+			await Promise.all([
+				tracerProvider.forceFlush(),
+				metricReader.forceFlush(),
+				loggerProvider.forceFlush()
+			]);
+		},
+		shutdown: async () => {
+			await Promise.all([
+				tracerProvider.shutdown(),
+				meterProvider.shutdown(),
+				loggerProvider.shutdown()
+			]);
+		}
+	};
+}
+//#endregion
+export { buildOtelProvider };

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.mjs","names":[],"sources":["../../../src/internal/otel/provider.ts"],"sourcesContent":["import type { SessionId } from \"@interfere/types/data/session\";\nimport type { ReleaseSlug } from \"@interfere/types/releases/slug\";\nimport { normalizeEnv } from \"@interfere/types/sdk/runtime\";\n\nimport { propagation } from \"@opentelemetry/api\";\nimport {\n  CompositePropagator,\n  W3CBaggagePropagator,\n  W3CTraceContextPropagator,\n} from \"@opentelemetry/core\";\nimport { browserDetector } from \"@opentelemetry/opentelemetry-browser-detector\";\nimport {\n  detectResources,\n  resourceFromAttributes,\n} from \"@opentelemetry/resources\";\nimport {\n  BatchLogRecordProcessor,\n  LoggerProvider,\n  type LogRecordProcessor,\n} from \"@opentelemetry/sdk-logs\";\nimport {\n  MeterProvider,\n  type MetricReader,\n  PeriodicExportingMetricReader,\n} from \"@opentelemetry/sdk-metrics\";\nimport {\n  BatchSpanProcessor,\n  type SpanProcessor,\n} from \"@opentelemetry/sdk-trace-base\";\nimport { WebTracerProvider } from \"@opentelemetry/sdk-trace-web\";\nimport {\n  createSessionLogRecordProcessor,\n  createSessionSpanProcessor,\n} from \"@opentelemetry/web-common\";\n\nimport { SDK_NAME, SDK_VERSION } from \"../version.js\";\nimport {\n  createBeaconLogExporter,\n  createBeaconMetricExporter,\n  createBeaconTraceExporter,\n} from \"./exporter.js\";\nimport { PageScopeContextManager } from \"./page-scope-context-manager.js\";\n\nconst SERVICE_NAMESPACE = \"interfere\";\n\n// Inlined wire keys — matches the pattern in\n// `@interfere/observability/browser/rum` (semconv keeps shifting these\n// between minor versions, but the wire keys themselves are stable).\nconst ATTR_SERVICE_NAME = \"service.name\" as const;\nconst ATTR_SERVICE_NAMESPACE = \"service.namespace\" as const;\nconst ATTR_DEPLOYMENT_ENVIRONMENT_NAME = \"deployment.environment.name\" as const;\nconst ATTR_TELEMETRY_SDK_LANGUAGE = \"telemetry.sdk.language\" as const;\nconst ATTR_RELEASE_SLUG = \"release.slug\" as const;\nconst ATTR_INTERFERE_SDK_STACK = \"interfere.sdk.stack\" as const;\nconst ATTR_INTERFERE_SDK_NAME = \"interfere.sdk.name\" as const;\nconst ATTR_INTERFERE_SDK_VERSION = \"interfere.sdk.version\" as const;\n// OTel semconv-canonical name for a stable per-device identifier.\n// Stamped as a *resource* attribute (not per-span) because it's stable\n// for the lifetime of the page; sessions rotate, devices don't. The\n// collector reads this off `context.resourceAttributes[\"device.id\"]`\n// and projects it into `spans.deviceId`.\nconst ATTR_DEVICE_ID = \"device.id\" as const;\n\nconst DEFAULT_SERVICE_NAME = \"interfere-sdk\";\n\n/**\n * Tuned for `navigator.sendBeacon`'s per-call payload ceiling.\n *\n * The browser primary exporters dispatch every export via beacon\n * (see `BeaconTraceExporter` / `BeaconLogExporter` /\n * `BeaconMetricExporter` in `exporter.ts`) — sendBeacon is the only\n * browser transport that reliably commits a request the page is also\n * tearing down. It's not free though: most browsers cap each beacon\n * payload at 64KiB (Chrome / Firefox) and reject anything larger\n * with a `false` return from `navigator.sendBeacon` — at which point\n * the BSP just drops the batch (no retry: the SW backstop intercepts\n * 5xx / network failures, not user-agent rejections).\n *\n * The numbers below keep payloads comfortably under that ceiling,\n * even on jank-heavy pages (production data on 2026-05-11 saw 831\n * `longtask` spans piled up on a single page-hide, observed via the\n * BetterStack dual-write) where a 100-span batch would already top\n * 100KiB:\n *\n *   - `maxExportBatchSize: 10` — caps each beacon at ~10–20KiB,\n *     leaving headroom for span attribute bloat without flirting\n *     with the per-call ceiling.\n *   - `maxQueueSize: 50` — caps the worst-case unload payload at\n *     ~50–100KiB; the BSP drains across 5 beacons when forced-\n *     flushed on `visibilitychange→hidden`, all of which queue\n *     synchronously inside the user agent.\n *   - `scheduledDelayMillis: 2000` — quieter pages keep less in\n *     buffer at any moment, so a hidden→visible→hidden bounce\n *     doesn't accumulate 5s of telemetry waiting to ship.\n *   - `exportTimeoutMillis: 10_000` — unchanged. Beacon dispatches\n *     are essentially synchronous (the user agent enqueues into its\n *     own send loop), so the timeout is mostly defensive against\n *     pathological `JsonTraceSerializer.serializeRequest` calls.\n */\nconst BROWSER_BATCH_OPTIONS = {\n  maxQueueSize: 50,\n  maxExportBatchSize: 10,\n  scheduledDelayMillis: 2000,\n  exportTimeoutMillis: 10_000,\n} as const;\n\nexport interface OtelProviderInput {\n  /**\n   * @internal\n   *\n   * Extra log-record processors fanned into the LoggerProvider's\n   * processor list at construction. Used by `@interfere/observability`\n   * for internal-only dual-write to BetterStack — keeps a parallel\n   * destination's queue/exporter independent of the SDK's own.\n   * Customers don't get a fan-out hook on the SDK surface; this is a\n   * private bridge for our own dogfood apps.\n   */\n  additionalLogRecordProcessors?: LogRecordProcessor[];\n  /**\n   * @internal\n   *\n   * Extra metric readers fanned into the MeterProvider's reader list\n   * at construction. Used by `@interfere/observability` for internal-\n   * only dual-write of web vitals histograms (`web_vitals.{ttfb,fcp,\n   * lcp,inp,cls}`) to the BetterStack-fronting OTel collector. Each\n   * reader owns its own queue + exporter so a 5xx / network outage on\n   * the parallel destination backs off only its own batch.\n   */\n  additionalMetricReaders?: MetricReader[];\n  /**\n   * @internal\n   *\n   * Extra span processors fanned into the WebTracerProvider's processor\n   * list at construction. See `additionalLogRecordProcessors`.\n   */\n  additionalSpanProcessors?: SpanProcessor[];\n  /**\n   * Auth + content headers for OTLP exports. Sourced from the kernel's\n   * already-resolved ingest target so the OTLP path inherits the same\n   * `x-interfere-pub-token` (or proxy-mode auth) the rest of the SDK\n   * uses — no separate auth knob.\n   */\n  authHeaders: Headers;\n  /** OTLP base URL — the opaque sink path is appended by the exporters. */\n  collectorUrl: string;\n  /**\n   * Stable per-device identifier from `DeviceManager`. Resolved from\n   * localStorage / cookie at kernel boot, so it's synchronously\n   * available before the providers are constructed. Stamped as the\n   * OTel-semconv `device.id` resource attribute so every span / log /\n   * metric carries it without per-record re-stamping. Optional —\n   * tests and SSR boot paths that build the provider before the\n   * device manager has run pass `null`.\n   */\n  deviceId?: string | null | undefined;\n  /**\n   * Returns the kernel's current session id. Wired into per-span /\n   * per-log session processors so a mid-page session rotation (30-min\n   * idle expiry, manual reset) lands on subsequent spans without the\n   * kernel having to rebuild the providers. Returns `null` before the\n   * `SessionTracker` has bootstrapped.\n   */\n  getSessionId: () => SessionId | null;\n  /** Optional release slug — top-level `release.slug` attr (Phase 6 wire identity). */\n  releaseSlug?: ReleaseSlug | null | undefined;\n  /**\n   * Producer chain for the `interfere.sdk.stack` resource attribute —\n   * e.g. `[\"@interfere/next@10.0.0\", \"@interfere/react@10.0.0\"]`.\n   * Wrapper-injected; the kernel just forwards.\n   */\n  sdkStack: string[];\n  /**\n   * Override the OTel `service.name` resource attribute. Defaults to\n   * `\"interfere-sdk\"`.\n   */\n  serviceName?: string;\n}\n\nexport interface OtelProviderHandle {\n  /**\n   * Page-scope context manager. The kernel calls `setPageScope(ctx)` after\n   * extracting the SSR `traceparent` meta tag so spans without a more\n   * specific zone descend from the server-side parent.\n   */\n  contextManager: PageScopeContextManager;\n  /** Force-flush all three providers — call from kernel.flush() / on visibility hidden. */\n  flush(): Promise<void>;\n  loggerProvider: LoggerProvider;\n  meterProvider: MeterProvider;\n  metricReader: MetricReader;\n  /** Tear down all three providers — called from kernel.dispose(). */\n  shutdown(): Promise<void>;\n  tracerProvider: WebTracerProvider;\n}\n\n/**\n * Constructs the SDK's **private** OTel providers — never registers globally\n * via `provider.register()` or `trace.setGlobalTracerProvider()`. Customers\n * with their own OTel setup (DataDog, Vercel, etc.) cohabit cleanly.\n *\n * Splitting this out from `Kernel` keeps the OTel module lazy-loadable so\n * the error-only bundle path (no tracing) never imports the OTel SDK.\n */\nexport function buildOtelProvider(\n  input: OtelProviderInput\n): OtelProviderHandle {\n  // Static service identity merged with detected browser attrs\n  // (`browser.brands`, `browser.platform`, `browser.mobile`,\n  // `browser.language`, `browser.user_agent`). The browser detector\n  // reads UA Client Hints synchronously via `navigator.userAgentData`\n  // low-entropy properties, so this stays sync — async would race\n  // `DocumentLoadInstrumentation` and consistently miss page-load.\n  const environment =\n    normalizeEnv(\n      typeof process === \"undefined\" ? undefined : process.env[\"NODE_ENV\"]\n    ) ?? \"unknown\";\n\n  const baseResource = resourceFromAttributes({\n    [ATTR_SERVICE_NAME]: input.serviceName ?? DEFAULT_SERVICE_NAME,\n    [ATTR_SERVICE_NAMESPACE]: SERVICE_NAMESPACE,\n    [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment,\n    [ATTR_TELEMETRY_SDK_LANGUAGE]: \"webjs\",\n    [ATTR_INTERFERE_SDK_NAME]: SDK_NAME,\n    [ATTR_INTERFERE_SDK_VERSION]: SDK_VERSION,\n    [ATTR_INTERFERE_SDK_STACK]: input.sdkStack.join(\", \"),\n    ...(input.releaseSlug ? { [ATTR_RELEASE_SLUG]: input.releaseSlug } : {}),\n    ...(input.deviceId ? { [ATTR_DEVICE_ID]: input.deviceId } : {}),\n  });\n  const detected = detectResources({ detectors: [browserDetector] });\n  const resource = baseResource.merge(detected);\n\n  const traceExporter = createBeaconTraceExporter({\n    collectorUrl: input.collectorUrl,\n    authHeaders: input.authHeaders,\n  });\n\n  // The web-common session processor expects `() => string | null`,\n  // matching our `KernelSession.getId` shape.\n  const getSessionId = input.getSessionId;\n\n  const spanProcessors: SpanProcessor[] = [\n    // Stamps `session.id` per-span, re-reading on every export. A\n    // mid-page session rotation (30-min idle, manual reset) lands on\n    // subsequent spans without rebuilding the provider. Resource-level\n    // `session.id` would freeze at boot.\n    createSessionSpanProcessor({ getSessionId }),\n    // Exception attribute defaults (`interfere.exception.{mechanism,\n    // handled,kind}`) are no longer stamped here — third-party\n    // auto-instrumentations bypass our kernel anyway, so the SDK\n    // can't reliably tell what to default. Server-side enrichment\n    // (`enrichment/lib/normalize-atom.ts`) is the single chokepoint\n    // every exception event flows through, so the defaults live\n    // there now and the SDK ships less code.\n    new BatchSpanProcessor(traceExporter, BROWSER_BATCH_OPTIONS),\n    // Internal-only fan-out (BetterStack dual-write for `interfere/homepage`\n    // + `interfere/dashboard`). Each extra processor owns its own queue +\n    // exporter, so a 5xx / network outage on the parallel destination\n    // backs off only its own batch — the primary collector pipeline keeps\n    // draining unaffected.\n    ...(input.additionalSpanProcessors ?? []),\n  ];\n\n  const tracerProvider = new WebTracerProvider({ resource, spanProcessors });\n\n  // `PageScopeContextManager` keeps the active context alive across\n  // microtasks/promise chains/setTimeout, AND falls back to the page-scope\n  // context (the SSR `traceparent`) for code paths that fire outside any\n  // zone the manager itself created. The kernel populates the page scope\n  // by calling `contextManager.setPageScope(ctx)` after extracting the\n  // meta tag.\n  //\n  // `register({ contextManager })` does call `setGlobalContextManager`\n  // internally — that's unavoidable; OTel exposes exactly one global\n  // context manager. Customers with their own OTel provider boot last and\n  // win. We accept the trade-off for correctness: the alternative\n  // (separate per-provider context manager) is not supported by OTel.\n  const contextManager = new PageScopeContextManager();\n  tracerProvider.register({ contextManager });\n\n  // Composed W3C trace context + baggage propagator. `FetchInstrumentation`\n  // injects both `traceparent` and `baggage` on outgoing requests so\n  // backend Elysia plugins can pick `interfere.*` baggage entries off\n  // the request and stamp them on server spans. Only set the global if\n  // no propagator is currently registered (`fields()` is `[]` for the\n  // noop). Customers who installed their own propagator (B3, composite,\n  // …) are preserved. Reading the SSR meta tag uses a local instance,\n  // not the global, so our extract path is independent.\n  if (propagation.fields().length === 0) {\n    propagation.setGlobalPropagator(\n      new CompositePropagator({\n        propagators: [\n          new W3CTraceContextPropagator(),\n          new W3CBaggagePropagator(),\n        ],\n      })\n    );\n  }\n\n  const metricExporter = createBeaconMetricExporter({\n    collectorUrl: input.collectorUrl,\n    authHeaders: input.authHeaders,\n  });\n\n  const metricReader = new PeriodicExportingMetricReader({\n    exporter: metricExporter,\n    exportIntervalMillis: 30_000,\n  });\n\n  const meterProvider = new MeterProvider({\n    resource,\n    readers: [metricReader, ...(input.additionalMetricReaders ?? [])],\n  });\n\n  // Logs path. The `plugins/logs.ts` plugin patches `console.*` and emits\n  // a `LogRecord` per call (errorsPlugin still owns Error-bearing console\n  // calls — the class boundary is checked there). LoggerProvider is\n  // private; the kernel exposes `recordLog` so callers don't have to\n  // touch the OTel logs API directly.\n  const logExporter = createBeaconLogExporter({\n    collectorUrl: input.collectorUrl,\n    authHeaders: input.authHeaders,\n  });\n  const loggerProvider = new LoggerProvider({\n    resource,\n    processors: [\n      // Mirrors the SessionSpanProcessor for traces — every log record\n      // (including `BrowserNavigationInstrumentation`'s navigation\n      // events) carries the same `session.id` as the spans emitted\n      // around it, so trace ↔ log correlation by session is trivial.\n      createSessionLogRecordProcessor({ getSessionId }),\n      new BatchLogRecordProcessor(logExporter, BROWSER_BATCH_OPTIONS),\n      ...(input.additionalLogRecordProcessors ?? []),\n    ],\n  });\n\n  return {\n    contextManager,\n    tracerProvider,\n    meterProvider,\n    metricReader,\n    loggerProvider,\n    flush: async () => {\n      await Promise.all([\n        tracerProvider.forceFlush(),\n        metricReader.forceFlush(),\n        loggerProvider.forceFlush(),\n      ]);\n    },\n    shutdown: async () => {\n      await Promise.all([\n        tracerProvider.shutdown(),\n        meterProvider.shutdown(),\n        loggerProvider.shutdown(),\n      ]);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AA2CA,MAAM,oBAAoB;AAK1B,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,mCAAmC;AACzC,MAAM,8BAA8B;AACpC,MAAM,oBAAoB;AAC1B,MAAM,2BAA2B;AACjC,MAAM,0BAA0B;AAChC,MAAM,6BAA6B;AAMnC,MAAM,iBAAiB;AAEvB,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoC7B,MAAM,wBAAwB;CAC5B,cAAc;CACd,oBAAoB;CACpB,sBAAsB;CACtB,qBAAqB;CACtB;;;;;;;;;AAmGD,SAAgB,kBACd,OACoB;CAOpB,MAAM,cACJ,aACE,OAAO,YAAY,cAAc,KAAA,IAAY,QAAQ,IAAI,YAC1D,IAAI;CAEP,MAAM,eAAe,uBAAuB;GACzC,oBAAoB,MAAM,eAAe;GACzC,yBAAyB;GACzB,mCAAmC;GACnC,8BAA8B;GAC9B,0BAA0B;GAC1B,6BAA6B;GAC7B,2BAA2B,MAAM,SAAS,KAAK,KAAK;EACrD,GAAI,MAAM,cAAc,GAAG,oBAAoB,MAAM,aAAa,GAAG,EAAE;EACvE,GAAI,MAAM,WAAW,GAAG,iBAAiB,MAAM,UAAU,GAAG,EAAE;EAC/D,CAAC;CACF,MAAM,WAAW,gBAAgB,EAAE,WAAW,CAAC,gBAAgB,EAAE,CAAC;CAClE,MAAM,WAAW,aAAa,MAAM,SAAS;CAE7C,MAAM,gBAAgB,0BAA0B;EAC9C,cAAc,MAAM;EACpB,aAAa,MAAM;EACpB,CAAC;CAIF,MAAM,eAAe,MAAM;CAwB3B,MAAM,iBAAiB,IAAI,kBAAkB;EAAE;EAAU,gBAAA;GAjBvD,2BAA2B,EAAE,cAAc,CAAC;GAQ5C,IAAI,mBAAmB,eAAe,sBAAsB;GAM5D,GAAI,MAAM,4BAA4B,EAAE;GAG6B;EAAE,CAAC;CAc1E,MAAM,iBAAiB,IAAI,yBAAyB;CACpD,eAAe,SAAS,EAAE,gBAAgB,CAAC;CAU3C,IAAI,YAAY,QAAQ,CAAC,WAAW,GAClC,YAAY,oBACV,IAAI,oBAAoB,EACtB,aAAa,CACX,IAAI,2BAA2B,EAC/B,IAAI,sBAAsB,CAC3B,EACF,CAAC,CACH;CAQH,MAAM,eAAe,IAAI,8BAA8B;EACrD,UANqB,2BAA2B;GAChD,cAAc,MAAM;GACpB,aAAa,MAAM;GACpB,CAGyB;EACxB,sBAAsB;EACvB,CAAC;CAEF,MAAM,gBAAgB,IAAI,cAAc;EACtC;EACA,SAAS,CAAC,cAAc,GAAI,MAAM,2BAA2B,EAAE,CAAE;EAClE,CAAC;CAOF,MAAM,cAAc,wBAAwB;EAC1C,cAAc,MAAM;EACpB,aAAa,MAAM;EACpB,CAAC;CACF,MAAM,iBAAiB,IAAI,eAAe;EACxC;EACA,YAAY;GAKV,gCAAgC,EAAE,cAAc,CAAC;GACjD,IAAI,wBAAwB,aAAa,sBAAsB;GAC/D,GAAI,MAAM,iCAAiC,EAAE;GAC9C;EACF,CAAC;CAEF,OAAO;EACL;EACA;EACA;EACA;EACA;EACA,OAAO,YAAY;GACjB,MAAM,QAAQ,IAAI;IAChB,eAAe,YAAY;IAC3B,aAAa,YAAY;IACzB,eAAe,YAAY;IAC5B,CAAC;;EAEJ,UAAU,YAAY;GACpB,MAAM,QAAQ,IAAI;IAChB,eAAe,UAAU;IACzB,cAAc,UAAU;IACxB,eAAe,UAAU;IAC1B,CAAC;;EAEL"}

package/dist/internal/otel/web-vitals.d.mts

@@ -0,0 +1,35 @@
+import { Meter } from "@opentelemetry/api";
+
+//#region src/internal/otel/web-vitals.d.ts
+interface WebVitalsInput {
+  /**
+   * Called after the page-load vitals have all fired. The kernel passes
+   * its own `flush()` so short-visit exports don't depend on the
+   * `visibilitychange` listener firing.
+   */
+  flush: () => Promise<void>;
+  /** OTel meter from the kernel's private provider. */
+  meter: Meter;
+  /**
+   * Pathname → low-cardinality route template (e.g. `/blog/[slug]`).
+   * Without this, dynamic routes produce one unique `url.path` label
+   * per visited slug — a metric cardinality hazard.
+   */
+  resolveRoute?: (pathname: string) => string | undefined;
+}
+/**
+ * Subscribes to Core Web Vitals (LCP/FCP/TTFB/INP/CLS) and records OTel
+ * histograms. Time-based vitals are converted to seconds per
+ * observability convention; CLS is dimensionless and recorded as-is.
+ *
+ * Each record carries `web_vital.rating`, `web_vital.navigation_type`,
+ * and `url.path` (templated when `resolveRoute` is provided). Browser
+ * and device dimensions come from the resource attached to the
+ * MeterProvider, so every histogram datapoint already carries them.
+ *
+ * Bucket boundaries match the rum.ts SDK — same dashboards, same
+ * histograms, same percentile shape.
+ */
+declare function captureWebVitals(input: WebVitalsInput): void;
+//#endregion
+export { WebVitalsInput, captureWebVitals };

package/dist/internal/otel/web-vitals.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-vitals.d.mts","names":[],"sources":["../../../src/internal/otel/web-vitals.ts"],"mappings":";;;UAmBiB,cAAA;;AAAjB;;;;EAME,KAAA,QAAa,OAAA;EAAA;EAEb,KAAA,EAAO,KAAA;EAAA;;;;;EAMP,YAAA,IAAgB,QAAA;AAAA;;;;;;;;;;;;;;iBAgBF,gBAAA,CAAiB,KAAA,EAAO,cAAA"}

package/dist/internal/otel/web-vitals.mjs

@@ -0,0 +1,162 @@
+import { onCLS, onFCP, onINP, onLCP, onTTFB } from "web-vitals";
+//#region src/internal/otel/web-vitals.ts
+const ATTR_URL_PATH = "url.path";
+const MS_TO_S = 1 / 1e3;
+/**
+* Vitals that fire during the page-load sequence — once we've received
+* all three we issue a one-shot flush so short visits still export
+* data. CLS and INP fire on `visibilitychange` which the kernel
+* already auto-flushes on, so they don't need their own trigger.
+*/
+const LOAD_VITALS = new Set([
+	"TTFB",
+	"FCP",
+	"LCP"
+]);
+/**
+* Subscribes to Core Web Vitals (LCP/FCP/TTFB/INP/CLS) and records OTel
+* histograms. Time-based vitals are converted to seconds per
+* observability convention; CLS is dimensionless and recorded as-is.
+*
+* Each record carries `web_vital.rating`, `web_vital.navigation_type`,
+* and `url.path` (templated when `resolveRoute` is provided). Browser
+* and device dimensions come from the resource attached to the
+* MeterProvider, so every histogram datapoint already carries them.
+*
+* Bucket boundaries match the rum.ts SDK — same dashboards, same
+* histograms, same percentile shape.
+*/
+function captureWebVitals(input) {
+	if (typeof window === "undefined") return;
+	const { meter, resolveRoute, flush } = input;
+	const lcp = meter.createHistogram("web_vitals.lcp", {
+		description: "Largest Contentful Paint",
+		unit: "s",
+		advice: { explicitBucketBoundaries: [
+			.5,
+			1,
+			1.5,
+			2,
+			2.5,
+			3,
+			4,
+			5,
+			7.5,
+			10
+		] }
+	});
+	const fcp = meter.createHistogram("web_vitals.fcp", {
+		description: "First Contentful Paint",
+		unit: "s",
+		advice: { explicitBucketBoundaries: [
+			.5,
+			1,
+			1.5,
+			1.8,
+			2,
+			2.5,
+			3,
+			4,
+			5,
+			7.5
+		] }
+	});
+	const ttfb = meter.createHistogram("web_vitals.ttfb", {
+		description: "Time to First Byte",
+		unit: "s",
+		advice: { explicitBucketBoundaries: [
+			.1,
+			.2,
+			.3,
+			.5,
+			.8,
+			1,
+			1.5,
+			2,
+			3,
+			5
+		] }
+	});
+	const inp = meter.createHistogram("web_vitals.inp", {
+		description: "Interaction to Next Paint",
+		unit: "s",
+		advice: { explicitBucketBoundaries: [
+			.05,
+			.1,
+			.15,
+			.2,
+			.3,
+			.4,
+			.5,
+			.75,
+			1,
+			2
+		] }
+	});
+	const cls = meter.createHistogram("web_vitals.cls", {
+		description: "Cumulative Layout Shift",
+		unit: "1",
+		advice: { explicitBucketBoundaries: [
+			.01,
+			.025,
+			.05,
+			.075,
+			.1,
+			.15,
+			.2,
+			.25,
+			.5,
+			1
+		] }
+	});
+	const vitals = {
+		LCP: {
+			histogram: lcp,
+			toSeconds: true
+		},
+		FCP: {
+			histogram: fcp,
+			toSeconds: true
+		},
+		TTFB: {
+			histogram: ttfb,
+			toSeconds: true
+		},
+		INP: {
+			histogram: inp,
+			toSeconds: true
+		},
+		CLS: {
+			histogram: cls,
+			toSeconds: false
+		}
+	};
+	const received = /* @__PURE__ */ new Set();
+	let flushed = false;
+	function report(metric) {
+		const entry = vitals[metric.name];
+		if (!entry) return;
+		const value = entry.toSeconds ? metric.value * MS_TO_S : metric.value;
+		const pathname = window.location.pathname;
+		const route = resolveRoute?.(pathname) ?? pathname;
+		entry.histogram.record(value, {
+			...metric.rating ? { "web_vital.rating": metric.rating } : {},
+			...metric.navigationType ? { "web_vital.navigation_type": metric.navigationType } : {},
+			[ATTR_URL_PATH]: route
+		});
+		if (!flushed && LOAD_VITALS.has(metric.name)) {
+			received.add(metric.name);
+			if (received.size === LOAD_VITALS.size) {
+				flushed = true;
+				flush().catch(() => void 0);
+			}
+		}
+	}
+	onLCP(report);
+	onCLS(report);
+	onINP(report);
+	onTTFB(report);
+	onFCP(report);
+}
+//#endregion
+export { captureWebVitals };

package/dist/internal/otel/web-vitals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-vitals.mjs","names":[],"sources":["../../../src/internal/otel/web-vitals.ts"],"sourcesContent":["import type { Histogram, Meter } from \"@opentelemetry/api\";\nimport { onCLS, onFCP, onINP, onLCP, onTTFB } from \"web-vitals\";\n\nconst ATTR_URL_PATH = \"url.path\" as const;\nconst MS_TO_S = 1 / 1000;\n\n/**\n * Vitals that fire during the page-load sequence — once we've received\n * all three we issue a one-shot flush so short visits still export\n * data. CLS and INP fire on `visibilitychange` which the kernel\n * already auto-flushes on, so they don't need their own trigger.\n */\nconst LOAD_VITALS = new Set([\"TTFB\", \"FCP\", \"LCP\"]);\n\ninterface VitalEntry {\n  histogram: Histogram;\n  toSeconds: boolean;\n}\n\nexport interface WebVitalsInput {\n  /**\n   * Called after the page-load vitals have all fired. The kernel passes\n   * its own `flush()` so short-visit exports don't depend on the\n   * `visibilitychange` listener firing.\n   */\n  flush: () => Promise<void>;\n  /** OTel meter from the kernel's private provider. */\n  meter: Meter;\n  /**\n   * Pathname → low-cardinality route template (e.g. `/blog/[slug]`).\n   * Without this, dynamic routes produce one unique `url.path` label\n   * per visited slug — a metric cardinality hazard.\n   */\n  resolveRoute?: (pathname: string) => string | undefined;\n}\n\n/**\n * Subscribes to Core Web Vitals (LCP/FCP/TTFB/INP/CLS) and records OTel\n * histograms. Time-based vitals are converted to seconds per\n * observability convention; CLS is dimensionless and recorded as-is.\n *\n * Each record carries `web_vital.rating`, `web_vital.navigation_type`,\n * and `url.path` (templated when `resolveRoute` is provided). Browser\n * and device dimensions come from the resource attached to the\n * MeterProvider, so every histogram datapoint already carries them.\n *\n * Bucket boundaries match the rum.ts SDK — same dashboards, same\n * histograms, same percentile shape.\n */\nexport function captureWebVitals(input: WebVitalsInput): void {\n  if (typeof window === \"undefined\") {\n    return;\n  }\n\n  const { meter, resolveRoute, flush } = input;\n\n  const lcp = meter.createHistogram(\"web_vitals.lcp\", {\n    description: \"Largest Contentful Paint\",\n    unit: \"s\",\n    advice: {\n      explicitBucketBoundaries: [0.5, 1, 1.5, 2, 2.5, 3, 4, 5, 7.5, 10],\n    },\n  });\n  const fcp = meter.createHistogram(\"web_vitals.fcp\", {\n    description: \"First Contentful Paint\",\n    unit: \"s\",\n    advice: {\n      explicitBucketBoundaries: [0.5, 1, 1.5, 1.8, 2, 2.5, 3, 4, 5, 7.5],\n    },\n  });\n  const ttfb = meter.createHistogram(\"web_vitals.ttfb\", {\n    description: \"Time to First Byte\",\n    unit: \"s\",\n    advice: {\n      explicitBucketBoundaries: [0.1, 0.2, 0.3, 0.5, 0.8, 1, 1.5, 2, 3, 5],\n    },\n  });\n  const inp = meter.createHistogram(\"web_vitals.inp\", {\n    description: \"Interaction to Next Paint\",\n    unit: \"s\",\n    advice: {\n      explicitBucketBoundaries: [\n        0.05, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.75, 1, 2,\n      ],\n    },\n  });\n  const cls = meter.createHistogram(\"web_vitals.cls\", {\n    description: \"Cumulative Layout Shift\",\n    unit: \"1\",\n    advice: {\n      explicitBucketBoundaries: [\n        0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.2, 0.25, 0.5, 1,\n      ],\n    },\n  });\n\n  const vitals: Record<string, VitalEntry> = {\n    LCP: { histogram: lcp, toSeconds: true },\n    FCP: { histogram: fcp, toSeconds: true },\n    TTFB: { histogram: ttfb, toSeconds: true },\n    INP: { histogram: inp, toSeconds: true },\n    CLS: { histogram: cls, toSeconds: false },\n  };\n\n  const received = new Set<string>();\n  let flushed = false;\n\n  function report(metric: {\n    name: string;\n    value: number;\n    rating?: string;\n    navigationType?: string;\n  }): void {\n    const entry = vitals[metric.name];\n    if (!entry) {\n      return;\n    }\n    const value = entry.toSeconds ? metric.value * MS_TO_S : metric.value;\n    const pathname = window.location.pathname;\n    const route = resolveRoute?.(pathname) ?? pathname;\n\n    entry.histogram.record(value, {\n      ...(metric.rating ? { \"web_vital.rating\": metric.rating } : {}),\n      ...(metric.navigationType\n        ? { \"web_vital.navigation_type\": metric.navigationType }\n        : {}),\n      [ATTR_URL_PATH]: route,\n    });\n\n    if (!flushed && LOAD_VITALS.has(metric.name)) {\n      received.add(metric.name);\n      if (received.size === LOAD_VITALS.size) {\n        flushed = true;\n        flush().catch(() => undefined);\n      }\n    }\n  }\n\n  onLCP(report);\n  onCLS(report);\n  onINP(report);\n  onTTFB(report);\n  onFCP(report);\n}\n"],"mappings":";;AAGA,MAAM,gBAAgB;AACtB,MAAM,UAAU,IAAI;;;;;;;AAQpB,MAAM,cAAc,IAAI,IAAI;CAAC;CAAQ;CAAO;CAAM,CAAC;;;;;;;;;;;;;;AAqCnD,SAAgB,iBAAiB,OAA6B;CAC5D,IAAI,OAAO,WAAW,aACpB;CAGF,MAAM,EAAE,OAAO,cAAc,UAAU;CAEvC,MAAM,MAAM,MAAM,gBAAgB,kBAAkB;EAClD,aAAa;EACb,MAAM;EACN,QAAQ,EACN,0BAA0B;GAAC;GAAK;GAAG;GAAK;GAAG;GAAK;GAAG;GAAG;GAAG;GAAK;GAAG,EAClE;EACF,CAAC;CACF,MAAM,MAAM,MAAM,gBAAgB,kBAAkB;EAClD,aAAa;EACb,MAAM;EACN,QAAQ,EACN,0BAA0B;GAAC;GAAK;GAAG;GAAK;GAAK;GAAG;GAAK;GAAG;GAAG;GAAG;GAAI,EACnE;EACF,CAAC;CACF,MAAM,OAAO,MAAM,gBAAgB,mBAAmB;EACpD,aAAa;EACb,MAAM;EACN,QAAQ,EACN,0BAA0B;GAAC;GAAK;GAAK;GAAK;GAAK;GAAK;GAAG;GAAK;GAAG;GAAG;GAAE,EACrE;EACF,CAAC;CACF,MAAM,MAAM,MAAM,gBAAgB,kBAAkB;EAClD,aAAa;EACb,MAAM;EACN,QAAQ,EACN,0BAA0B;GACxB;GAAM;GAAK;GAAM;GAAK;GAAK;GAAK;GAAK;GAAM;GAAG;GAC/C,EACF;EACF,CAAC;CACF,MAAM,MAAM,MAAM,gBAAgB,kBAAkB;EAClD,aAAa;EACb,MAAM;EACN,QAAQ,EACN,0BAA0B;GACxB;GAAM;GAAO;GAAM;GAAO;GAAK;GAAM;GAAK;GAAM;GAAK;GACtD,EACF;EACF,CAAC;CAEF,MAAM,SAAqC;EACzC,KAAK;GAAE,WAAW;GAAK,WAAW;GAAM;EACxC,KAAK;GAAE,WAAW;GAAK,WAAW;GAAM;EACxC,MAAM;GAAE,WAAW;GAAM,WAAW;GAAM;EAC1C,KAAK;GAAE,WAAW;GAAK,WAAW;GAAM;EACxC,KAAK;GAAE,WAAW;GAAK,WAAW;GAAO;EAC1C;CAED,MAAM,2BAAW,IAAI,KAAa;CAClC,IAAI,UAAU;CAEd,SAAS,OAAO,QAKP;EACP,MAAM,QAAQ,OAAO,OAAO;EAC5B,IAAI,CAAC,OACH;EAEF,MAAM,QAAQ,MAAM,YAAY,OAAO,QAAQ,UAAU,OAAO;EAChE,MAAM,WAAW,OAAO,SAAS;EACjC,MAAM,QAAQ,eAAe,SAAS,IAAI;EAE1C,MAAM,UAAU,OAAO,OAAO;GAC5B,GAAI,OAAO,SAAS,EAAE,oBAAoB,OAAO,QAAQ,GAAG,EAAE;GAC9D,GAAI,OAAO,iBACP,EAAE,6BAA6B,OAAO,gBAAgB,GACtD,EAAE;IACL,gBAAgB;GAClB,CAAC;EAEF,IAAI,CAAC,WAAW,YAAY,IAAI,OAAO,KAAK,EAAE;GAC5C,SAAS,IAAI,OAAO,KAAK;GACzB,IAAI,SAAS,SAAS,YAAY,MAAM;IACtC,UAAU;IACV,OAAO,CAAC,YAAY,KAAA,EAAU;;;;CAKpC,MAAM,OAAO;CACb,MAAM,OAAO;CACb,MAAM,OAAO;CACb,OAAO,OAAO;CACd,MAAM,OAAO"}

package/dist/internal/page-lifecycle.d.mts

@@ -0,0 +1,21 @@
+//#region src/internal/page-lifecycle.d.ts
+/**
+ * Single subscription point for `visibilitychange` (hidden) and
+ * `beforeunload`. Modules call `onPageHidden(handler)` and the handler
+ * fires once per transition into hidden / unload.
+ *
+ * Replaces the previous shape where the kernel, the queue, the pages
+ * plugin, and the replay plugin each attached their own listeners — four
+ * subscribers racing to flush / drain / emit on the same boundary, with
+ * no shared lifecycle. One subscription, many handlers, no coordination
+ * via the global event subsystem.
+ *
+ * Both events can fire (visibilitychange first when the user navigates
+ * away, then sometimes beforeunload). Handlers must be idempotent.
+ */
+type Handler = () => void;
+declare function onPageHidden(handler: Handler): () => void;
+/** Test hook — drops every handler and unbinds the listeners. */
+declare function _resetPageLifecycleForTests(): void;
+//#endregion
+export { _resetPageLifecycleForTests, onPageHidden };

package/dist/internal/page-lifecycle.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-lifecycle.d.mts","names":[],"sources":["../../src/internal/page-lifecycle.ts"],"mappings":";;;;;;;AA2CA;;;;;AASA;;;KAtCK,OAAA;AAAA,iBA6BW,YAAA,CAAa,OAAA,EAAS,OAAA;;iBAStB,2BAAA,CAAA"}

package/dist/internal/page-lifecycle.mjs

@@ -0,0 +1,33 @@
+//#region src/internal/page-lifecycle.ts
+const handlers = /* @__PURE__ */ new Set();
+let installed = false;
+function fire() {
+	for (const handler of handlers) handler();
+}
+function onVisibilityChange() {
+	if (typeof document !== "undefined" && document.visibilityState === "hidden") fire();
+}
+function install() {
+	if (installed || typeof globalThis.addEventListener !== "function") return;
+	installed = true;
+	globalThis.addEventListener("visibilitychange", onVisibilityChange);
+	globalThis.addEventListener("beforeunload", fire);
+}
+function onPageHidden(handler) {
+	install();
+	handlers.add(handler);
+	return () => {
+		handlers.delete(handler);
+	};
+}
+/** Test hook — drops every handler and unbinds the listeners. */
+function _resetPageLifecycleForTests() {
+	handlers.clear();
+	if (installed && typeof globalThis.removeEventListener === "function") {
+		globalThis.removeEventListener("visibilitychange", onVisibilityChange);
+		globalThis.removeEventListener("beforeunload", fire);
+	}
+	installed = false;
+}
+//#endregion
+export { _resetPageLifecycleForTests, onPageHidden };

package/dist/internal/page-lifecycle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-lifecycle.mjs","names":[],"sources":["../../src/internal/page-lifecycle.ts"],"sourcesContent":["/**\n * Single subscription point for `visibilitychange` (hidden) and\n * `beforeunload`. Modules call `onPageHidden(handler)` and the handler\n * fires once per transition into hidden / unload.\n *\n * Replaces the previous shape where the kernel, the queue, the pages\n * plugin, and the replay plugin each attached their own listeners — four\n * subscribers racing to flush / drain / emit on the same boundary, with\n * no shared lifecycle. One subscription, many handlers, no coordination\n * via the global event subsystem.\n *\n * Both events can fire (visibilitychange first when the user navigates\n * away, then sometimes beforeunload). Handlers must be idempotent.\n */\ntype Handler = () => void;\n\nconst handlers = new Set<Handler>();\nlet installed = false;\n\nfunction fire(): void {\n  for (const handler of handlers) {\n    handler();\n  }\n}\n\nfunction onVisibilityChange(): void {\n  if (\n    typeof document !== \"undefined\" &&\n    document.visibilityState === \"hidden\"\n  ) {\n    fire();\n  }\n}\n\nfunction install(): void {\n  if (installed || typeof globalThis.addEventListener !== \"function\") {\n    return;\n  }\n  installed = true;\n  globalThis.addEventListener(\"visibilitychange\", onVisibilityChange);\n  globalThis.addEventListener(\"beforeunload\", fire);\n}\n\nexport function onPageHidden(handler: Handler): () => void {\n  install();\n  handlers.add(handler);\n  return () => {\n    handlers.delete(handler);\n  };\n}\n\n/** Test hook — drops every handler and unbinds the listeners. */\nexport function _resetPageLifecycleForTests(): void {\n  handlers.clear();\n  if (installed && typeof globalThis.removeEventListener === \"function\") {\n    globalThis.removeEventListener(\"visibilitychange\", onVisibilityChange);\n    globalThis.removeEventListener(\"beforeunload\", fire);\n  }\n  installed = false;\n}\n"],"mappings":";AAgBA,MAAM,2BAAW,IAAI,KAAc;AACnC,IAAI,YAAY;AAEhB,SAAS,OAAa;CACpB,KAAK,MAAM,WAAW,UACpB,SAAS;;AAIb,SAAS,qBAA2B;CAClC,IACE,OAAO,aAAa,eACpB,SAAS,oBAAoB,UAE7B,MAAM;;AAIV,SAAS,UAAgB;CACvB,IAAI,aAAa,OAAO,WAAW,qBAAqB,YACtD;CAEF,YAAY;CACZ,WAAW,iBAAiB,oBAAoB,mBAAmB;CACnE,WAAW,iBAAiB,gBAAgB,KAAK;;AAGnD,SAAgB,aAAa,SAA8B;CACzD,SAAS;CACT,SAAS,IAAI,QAAQ;CACrB,aAAa;EACX,SAAS,OAAO,QAAQ;;;;AAK5B,SAAgB,8BAAoC;CAClD,SAAS,OAAO;CAChB,IAAI,aAAa,OAAO,WAAW,wBAAwB,YAAY;EACrE,WAAW,oBAAoB,oBAAoB,mBAAmB;EACtE,WAAW,oBAAoB,gBAAgB,KAAK;;CAEtD,YAAY"}

package/dist/internal/plugin-runtime.d.mts

@@ -2,7 +2,6 @@ import { PluginContext } from "../plugins/lib/types.mjs";
 import { PluginOverrides } from "../plugins/lib/loader.mjs";
 import { ConsentState } from "@interfere/types/sdk/plugins/manifest";
 import { RemotePluginConfig } from "@interfere/types/sdk/remote-config";
-import { EventType } from "@interfere/types/sdk/envelope";
 
 //#region src/internal/plugin-runtime.d.ts
 declare class PluginRuntime {
@@ -19,7 +18,6 @@ declare class PluginRuntime {
   setConsent(nextConsent?: ConsentState): void;
   resetConsent(): void;
   applyRemoteConfig(config: RemotePluginConfig): void;
-  canCapture(type: EventType): boolean;
   start(): void;
   dispose(): Promise<void>;
   private shouldEnablePlugin;

package/dist/internal/plugin-runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-runtime.d.mts","names":[],"sources":["../../src/internal/plugin-runtime.ts"],"mappings":";;;;;;;cA6Ba,aAAA;EAAA,iBACM,cAAA;EAAA,iBACA,OAAA;EAAA,iBACA,OAAA;EAAA,iBACA,QAAA;EAAA,QACT,YAAA;EAAA,QACA,YAAA;EAAA,QACA,WAAA;EAAA,QACA,QAAA;cAGN,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,eAAA,cACX,cAAA,EAAgB,YAAA;EAOlB,UAAA,CAAA,GAAc,YAAA;EAId,UAAA,CAAW,WAAA,GAAc,YAAA;EAUzB,YAAA,CAAA;EASA,iBAAA,CAAkB,MAAA,EAAQ,kBAAA;EAK1B,UAAA,CAAW,IAAA,EAAM,SAAA;EAQjB,KAAA,CAAA;EAWM,OAAA,CAAA,GAAW,OAAA;EAAA,QAWT,kBAAA;EAAA,QAQA,UAAA;EAAA,QAeM,QAAA;EAAA,QAoBN,IAAA;AAAA"}
+{"version":3,"file":"plugin-runtime.d.mts","names":[],"sources":["../../src/internal/plugin-runtime.ts"],"mappings":";;;;;;cAwBa,aAAA;EAAA,iBACM,cAAA;EAAA,iBACA,OAAA;EAAA,iBACA,OAAA;EAAA,iBACA,QAAA;EAAA,QACT,YAAA;EAAA,QACA,YAAA;EAAA,QACA,WAAA;EAAA,QACA,QAAA;cAGN,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,eAAA,cACX,cAAA,EAAgB,YAAA;EAOlB,UAAA,CAAA,GAAc,YAAA;EAId,UAAA,CAAW,WAAA,GAAc,YAAA;EAUzB,YAAA,CAAA;EASA,iBAAA,CAAkB,MAAA,EAAQ,kBAAA;EAK1B,KAAA,CAAA;EAWM,OAAA,CAAA,GAAW,OAAA;EAAA,QAWT,kBAAA;EAAA,QAQA,UAAA;EAAA,QAeM,QAAA;EAAA,QAoBN,IAAA;AAAA"}

package/dist/internal/plugin-runtime.mjs

@@ -1,9 +1,8 @@
 import { createLogger } from "../util/log.mjs";
+import { getPluginConsentCategory, hasConsentChanged, isConsentAllowed, resolveGrantedConsent } from "./consent.mjs";
 import errorsPlugin from "../plugins/errors.mjs";
 import { loadPlugin, resolveFeatures } from "../plugins/lib/loader.mjs";
-import { getPluginConsentCategory, hasConsentChanged, isConsentAllowed, resolveGrantedConsent, shouldCaptureEvent } from "./consent.mjs";
 import { PLUGIN_MANIFEST } from "@interfere/types/sdk/plugins/manifest";
-import { EVENT_TYPE_TO_PLUGIN } from "@interfere/types/sdk/remote-config";
 //#region src/internal/plugin-runtime.ts
 const log = createLogger("plugin-runtime");
 var PluginRuntime = class {
@@ -38,11 +37,6 @@ var PluginRuntime = class {
 		this.remoteConfig = config;
 		this.sync();
 	}
-	canCapture(type) {
-		const plugin = EVENT_TYPE_TO_PLUGIN[type];
-		if (plugin && this.remoteConfig[plugin] === false) return false;
-		return shouldCaptureEvent(type, this.consentState);
-	}
 	start() {
 		if (this.shouldEnablePlugin("errors")) {
 			const cleanup = errorsPlugin.setup(this.context);