@logbrew/sdk 0.1.37 → 0.1.39

package/core.cjs

@@ -1,3004 +1,50 @@
-const { buildCreateSupportTicketDraft } = require("./support-ticket.cjs");
-const { buildIssueDiagnosticsHelpers } = require("./issue-diagnostics.cjs");
-const { buildIssueStackHelpers } = require("./issue-stack.cjs");
-const { buildLogContextHelpers } = require("./log-context.cjs");
-const { buildOpenTelemetryHelpers } = require("./opentelemetry.cjs");
-const { buildTelemetryContextHelpers } = require("./telemetry-context.cjs");
-const { buildTraceContextHelpers } = require("./trace-context.cjs");
-
-const SEVERITY_ALIASES = new Map([
-  ["trace", "info"],
-  ["debug", "info"],
-  ["info", "info"],
-  ["warn", "warning"],
-  ["warning", "warning"],
-  ["error", "error"],
-  ["fatal", "critical"],
-  ["critical", "critical"]
-]);
-const SEVERITY_VALUES = new Set(SEVERITY_ALIASES.keys());
-const EVENT_ADMISSIONS = Object.freeze({
-  admitted: Object.freeze({ status: "admitted" }),
-  filtered: Object.freeze({ status: "filtered" }),
-  unavailable: Object.freeze({ status: "unavailable" }),
-  event_too_large: Object.freeze({ status: "dropped", reason: "event_too_large" }),
-  queue_overflow: Object.freeze({ status: "dropped", reason: "queue_overflow" }),
-  queue_bytes_overflow: Object.freeze({ status: "dropped", reason: "queue_bytes_overflow" })
-});
-const SPAN_STATUSES = new Set(["ok", "error"]);
-const ACTION_STATUSES = new Set(["queued", "running", "success", "failure"]);
-const PRODUCT_ANALYTICS_SCHEMA_VERSION = 1;
-const PRODUCT_ANALYTICS_KINDS = Object.freeze(["page_view", "screen_view", "interaction"]);
-const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;
-const METRIC_KINDS = new Set(["counter", "gauge", "histogram"]);
-const MAX_METRIC_DESCRIPTION_LENGTH = 1024;
-const NON_NEGATIVE_METRIC_KINDS = new Set(["counter", "histogram"]);
-const METRIC_TEMPORALITIES_BY_KIND = new Map([
-  ["counter", new Set(["delta", "cumulative"])],
-  ["gauge", new Set(["instant"])],
-  ["histogram", new Set(["delta", "cumulative"])]
-]);
-const CONSOLE_METHODS = new Set(["debug", "info", "log", "warn", "error"]);
-const DEFAULT_CONSOLE_LEVELS = ["debug", "info", "log", "warn", "error"];
-const PINO_HOST_FIELD = ["host", "name"].join("");
-const PINO_RESERVED_FIELDS = new Set(["level", "time", "timestamp", "msg", "message", "err", "error", "pid", PINO_HOST_FIELD, "v"]);
-const PINO_SENSITIVE_CONTEXT_FIELDS = new Set([
-  "apikey",
-  "authorization",
-  "baggage",
-  "body",
-  "cookie",
-  "credentials",
-  "cwd",
-  "directory",
-  "dirname",
-  "errorstack",
-  "file",
-  "filename",
-  "filepath",
-  "headers",
-  "href",
-  "key",
-  "password",
-  "payload",
-  "proxyauthorization",
-  "query",
-  "querystring",
-  "requestbody",
-  "requestheaders",
-  "requesturl",
-  "responsebody",
-  "responseheaders",
-  "responseurl",
-  "search",
-  "secret",
-  "setcookie",
-  "stack",
-  "token",
-  "traceparent",
-  "tracestate",
-  "uri",
-  "url"
-]);
-const TRACEPARENT_PATTERN = /^([0-9a-fA-F]{2})-([0-9a-fA-F]{32})-([0-9a-fA-F]{16})-([0-9a-fA-F]{2})$/u;
-const ZERO_TRACE_ID = "00000000000000000000000000000000";
-const ZERO_SPAN_ID = "0000000000000000";
-const RFC3339_TIMESTAMP_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u;
-const DEFAULT_MAX_QUEUE_SIZE = 1000;
-const DEFAULT_MAX_QUEUE_BYTES = 4 * 1024 * 1024;
-const DEFAULT_MAX_BATCH_EVENTS = 100;
-const DEFAULT_MAX_BATCH_BYTES = 256 * 1024;
-// One second matches the OpenTelemetry log processor default, so a lone event becomes readable quickly.
-const DEFAULT_DELIVERY_INTERVAL_MS = 1000;
-const MAX_DELIVERY_INTERVAL_MS = 60 * 1000;
-// A rate-limited batch waits from 1 second to 1 hour, plus up to 10 percent jitter, before it is sent again.
-const MIN_RATE_LIMIT_WAIT_MS = 1000;
-const MAX_RATE_LIMIT_WAIT_MS = 60 * 60 * 1000;
-const DEFAULT_DELIVERY_QUEUE_THRESHOLD = 50;
-const MAX_CLIENT_REPORT_REASONS = 16;
-const MAX_CLIENT_REPORT_COUNT = 1_000_000_000;
-const DELIVERY_HEALTH_SCHEMA_VERSION = 1;
-const EVENT_QUEUE_FACTORY = Symbol.for("@logbrew/sdk.eventQueueFactory");
-// Runtimes without an event store (browser storage) persist unreported drop counts through this seam.
-const CLIENT_REPORT_STORE = Symbol.for("@logbrew/sdk.clientReportStore");
-const CLIENT_REPORT_SAVE_INTERVAL_MS = 1_000;
-const CLIENT_REPORT_ID_PATTERN = /^[A-Za-z0-9_-]{16,64}$/u;
-const CLIENT_REPORT_REASON_PATTERN = /^[a-z][a-z0-9_]{0,63}$/u;
-const CONTEXT_PROVIDER = Symbol.for("@logbrew/sdk.contextProvider");
-// Runtime packages supply request-scoped breadcrumbs through this seam; core merges them into issues.
-const BREADCRUMB_PROVIDER = Symbol.for("@logbrew/sdk.breadcrumbProvider");
-const MAX_ERROR_CAUSES = 5;
-const BUILTIN_ERROR_NAMES = new Set([
-  "AggregateError",
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError"
-]);
-const MAX_SPAN_EVENTS = 8;
-const MAX_SPAN_LINKS = 8;
-const EVENT_VALIDATORS = new Map([
-  ["release", validateRelease],
-  ["environment", validateEnvironment],
-  ["issue", validateIssue],
-  ["log", validateLog],
-  ["span", validateSpan],
-  ["action", validateAction],
-  ["metric", validateMetric]
-]);
-class SdkError extends Error {
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "SdkError";
-    this.code = code;
-    const retryAfterMs = retryAfterMsOrUndefined(details?.retryAfterMs);
-    if (retryAfterMs !== undefined) {
-      this.retryAfterMs = retryAfterMs;
-    }
-    if (details?.retryable === true) {
-      this.retryable = true;
-    }
-  }
-}
-
-const {
-  compactMetadata,
-  isMetadataValue,
-  normalizeLogTraceContext,
-  traceFromProvider,
-  traceMetadataFromLogContext
-} = buildLogContextHelpers({ SdkError });
-
-const {
-  javascriptStackEvidence,
-  validateIssueStackFrames,
-  validateNativeStackFrames
-} = buildIssueStackHelpers({ SdkError });
+const { installBrowserBreadcrumbs } = require("./browser-breadcrumbs.cjs");
+const { LogBrewClient } = require("./client.cjs");
+const { installLogBrewConsoleCapture } = require("./console-capture.cjs");
+const { logAttributesFromConsoleArgs, logbrewLevelFromConsoleMethod } = require("./console-arguments.cjs");
+const { createIssueAttributesFromError } = require("./error-issue.cjs");
+const { createNetworkMilestoneAttributes } = require("./network-milestone.cjs");
 const {
-  MAX_ISSUE_BREADCRUMBS,
-  cloneIssueDiagnostics,
-  createIssueException,
-  validateIssueBreadcrumb,
-  validateIssueDiagnostics,
-  validateIssueEvidence
-} = buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp, validateIssueStackFrames });
+  createLogBrewOpenTelemetrySpanExporter,
+  createLogBrewOpenTelemetrySpanProcessor,
+  logbrewTraceContextFromCurrentOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpanContext,
+  spanAttributesFromOpenTelemetryReadableSpan
+} = require("./opentelemetry.cjs");
+const { createLogBrewPinoDestination } = require("./pino-destination.cjs");
+const { logAttributesFromPinoRecord } = require("./pino-record.cjs");
 const {
-  cloneTelemetryContext,
-  mergeTelemetryContexts,
-  validateTelemetryContext
-} = buildTelemetryContextHelpers({ SdkError });
-
-class TransportError extends Error {
-  constructor(code, message, retryable = false) {
-    super(message);
-    this.name = "TransportError";
-    this.code = code;
-    this.retryable = retryable;
-  }
-
-  static network(message) {
-    return new TransportError("network_failure", message, true);
-  }
-}
-
-class RecordingTransport {
-  constructor(scriptedResponses = [{ statusCode: 202 }]) {
-    this.scriptedResponses = [...scriptedResponses];
-    this.sentBodies = [];
-  }
-
-  static alwaysAccept() {
-    return new RecordingTransport([{ statusCode: 202 }]);
-  }
-
-  lastBody() {
-    return this.sentBodies.at(-1) ?? null;
-  }
-
-  async send(apiKey, body) {
-    requireNonEmpty("apiKey", apiKey);
-    this.sentBodies.push(body);
-
-    const next = this.scriptedResponses.length > 0
-      ? this.scriptedResponses.shift()
-      : { statusCode: 202 };
-
-    if (next instanceof Error) {
-      throw next;
-    }
-
-    const retryAfterMs = retryAfterMsOrUndefined(next.retryAfterMs);
-    return {
-      statusCode: next.statusCode,
-      attempts: 1,
-      ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-      ...(typeof next.errorCode === "string" ? { errorCode: next.errorCode } : {})
-    };
-  }
-}
-
-class LogBrewClient {
-  static #issueCapture = LogBrewClient.prototype.issue;
-
-  static create({
-    apiKey,
-    sdkName,
-    sdkVersion,
-    context,
-    [CONTEXT_PROVIDER]: contextProvider,
-    [BREADCRUMB_PROVIDER]: breadcrumbProvider,
-    maxRetries = 2,
-    eventFilter,
-    maxQueueSize = DEFAULT_MAX_QUEUE_SIZE,
-    maxQueueBytes = DEFAULT_MAX_QUEUE_BYTES,
-    maxBatchEvents = DEFAULT_MAX_BATCH_EVENTS,
-    maxBatchBytes = DEFAULT_MAX_BATCH_BYTES,
-    onEventDropped,
-    eventStore,
-    [EVENT_QUEUE_FACTORY]: eventQueueFactory,
-    [CLIENT_REPORT_STORE]: clientReportStore,
-    transport,
-    automaticDelivery = transport !== undefined,
-    deliveryIntervalMs = DEFAULT_DELIVERY_INTERVAL_MS,
-    deliveryQueueThreshold = Math.min(DEFAULT_DELIVERY_QUEUE_THRESHOLD, maxQueueSize)
-  }) {
-    requireNonEmpty("apiKey", apiKey);
-    requireNonEmpty("sdkName", sdkName);
-    requireNonEmpty("sdkVersion", sdkVersion);
-    const clientContext = validateTelemetryContext(context, "client telemetry context");
-    if (contextProvider !== undefined && typeof contextProvider !== "function") {
-      throw new SdkError("validation_error", "context provider must be a function");
-    }
-    if (breadcrumbProvider !== undefined && typeof breadcrumbProvider !== "function") {
-      throw new SdkError("validation_error", "breadcrumb provider must be a function");
-    }
-    requireNonNegativeInteger("maxRetries", maxRetries);
-    if (eventFilter !== undefined && typeof eventFilter !== "function") {
-      throw new SdkError("validation_error", "eventFilter must be a function");
-    }
-    requirePositiveInteger("maxQueueSize", maxQueueSize);
-    requirePositiveInteger("maxQueueBytes", maxQueueBytes);
-    requirePositiveInteger("maxBatchEvents", maxBatchEvents);
-    requirePositiveInteger("maxBatchBytes", maxBatchBytes);
-    if (onEventDropped !== undefined && typeof onEventDropped !== "function") {
-      throw new SdkError("validation_error", "onEventDropped must be a function");
-    }
-    validateEventStore(eventStore);
-    if (eventQueueFactory !== undefined && typeof eventQueueFactory !== "function") {
-      throw new SdkError("validation_error", "event queue factory must be a function");
-    }
-    if (eventStore !== undefined && eventQueueFactory !== undefined) {
-      throw new SdkError("validation_error", "eventStore and event queue factory are mutually exclusive");
-    }
-    if (clientReportStore !== undefined && !isClientReportStore(clientReportStore)) {
-      throw new SdkError("validation_error", "client report store must provide loadClientReport and saveClientReport");
-    }
-    validateTransport(transport);
-    if (typeof automaticDelivery !== "boolean") {
-      throw new SdkError("validation_error", "automaticDelivery must be a boolean");
-    }
-    if (automaticDelivery && transport === undefined) {
-      throw new SdkError("validation_error", "automaticDelivery requires transport");
-    }
-    requirePositiveInteger("deliveryIntervalMs", deliveryIntervalMs);
-    if (deliveryIntervalMs > MAX_DELIVERY_INTERVAL_MS) {
-      throw new SdkError("validation_error", `deliveryIntervalMs must be at most ${MAX_DELIVERY_INTERVAL_MS}`);
-    }
-    requirePositiveInteger("deliveryQueueThreshold", deliveryQueueThreshold);
-    if (deliveryQueueThreshold > maxQueueSize) {
-      throw new SdkError("validation_error", "deliveryQueueThreshold must not exceed maxQueueSize");
-    }
-
-    return new LogBrewClient({
-      apiKey,
-      automaticDelivery,
-      deliveryIntervalMs,
-      deliveryQueueThreshold,
-      eventStore,
-      eventQueueFactory,
-      clientReportStore,
-      eventFilter,
-      maxBatchBytes,
-      maxBatchEvents,
-      maxQueueBytes,
-      maxQueueSize,
-      onEventDropped,
-      context: clientContext,
-      contextProvider,
-      breadcrumbProvider,
-      sdk: {
-        name: sdkName,
-        language: "javascript",
-        version: sdkVersion
-      },
-      maxRetries,
-      transport
-    });
-  }
-
-  constructor({
-    apiKey,
-    sdk,
-    maxRetries,
-    eventFilter,
-    maxBatchBytes,
-    maxBatchEvents,
-    maxQueueBytes,
-    maxQueueSize,
-    onEventDropped,
-    context,
-    contextProvider,
-    breadcrumbProvider,
-    eventStore,
-    eventQueueFactory,
-    clientReportStore,
-    transport,
-    automaticDelivery,
-    deliveryIntervalMs,
-    deliveryQueueThreshold
-  }) {
-    this.apiKey = apiKey;
-    this.automaticDelivery = automaticDelivery;
-    this.deliveryIntervalMs = deliveryIntervalMs;
-    this.deliveryQueueThreshold = deliveryQueueThreshold;
-    this.eventFilter = eventFilter;
-    this.maxBatchBytes = maxBatchBytes;
-    this.maxBatchEvents = maxBatchEvents;
-    this.maxQueueBytes = maxQueueBytes;
-    this.maxQueueSize = maxQueueSize;
-    this.onEventDropped = onEventDropped;
-    this.context = cloneTelemetryContext(context);
-    this.contextProvider = contextProvider;
-    this.breadcrumbProvider = breadcrumbProvider;
-    this.transport = transport;
-    this.sdk = sdk;
-    this.maxRetries = maxRetries;
-    this.batchPrefix = `{"sdk":${JSON.stringify(this.sdk)},"events":[`;
-    this.batchPrefixBytes = utf8ByteLength(this.batchPrefix);
-    this.batchSuffix = "]}";
-    this.batchSuffixBytes = utf8ByteLength(this.batchSuffix);
-    const ownsEventStore = eventQueueFactory !== undefined;
-    const resolvedEventStore = ownsEventStore
-      ? createEventStoreFromQueueFactory(eventQueueFactory, {
-          batchPrefixBytes: this.batchPrefixBytes,
-          batchSuffixBytes: this.batchSuffixBytes,
-          maxBatchBytes,
-          maxQueueBytes,
-          maxQueueSize
-        })
-      : eventStore;
-    this.eventStore = resolvedEventStore;
-    let recovered;
-    try {
-      recovered = loadStoredEvents(this);
-    } catch (error) {
-      if (ownsEventStore) {
-        try {
-          requireSynchronousStoreResult("close", resolvedEventStore.close());
-        } catch {
-          // Preserve the queue construction or recovery failure.
-        }
-      }
-      throw error;
-    }
-    this.events = recovered.events;
-    this.serializedEvents = recovered.serializedEvents;
-    this.serializedEventBytes = recovered.serializedEventBytes;
-    this.queuedEventBytes = recovered.queuedEventBytes;
-    this.operationTail = Promise.resolve();
-    this.pendingOperations = 0;
-    this.closing = false;
-    this.closed = false;
-    this.droppedEventCount = 0;
-    this.droppedEventsByReason = {
-      event_too_large: 0,
-      evicted_for_fatal: 0,
-      queue_bytes_overflow: 0,
-      queue_overflow: 0
-    };
-    // A persistent store keeps counts not yet acknowledged by a 2xx across restarts.
-    this.clientReportStore = clientReportStore
-      ?? (isClientReportStore(resolvedEventStore) ? resolvedEventStore : undefined);
-    this.clientReportSavedAtMs = 0;
-    const restoredReport = loadClientReport(this.clientReportStore);
-    this.unreportedDropsByReason = restoredReport.unreported;
-    // Drop counts frozen under one report ID until a 2xx acknowledges a body that carried them.
-    this.pendingClientReport = restoredReport.pending;
-    this.lastDropReason = "none";
-    this.storage = resolvedEventStore ? "persistent" : "memory";
-    this.hydratedEventCount = recovered.events.length;
-    this.hydratedEventBytes = recovered.queuedEventBytes;
-    this.deliveryTimer = undefined;
-    this.automaticFlushActive = false;
-    this.automaticFlushPending = false;
-    this.deliveryInFlight = false;
-    this.lastDeliveryOutcome = "idle";
-    this.automaticPauseReason = "none";
-    this.consecutiveDeliveryFailures = 0;
-    this.retryDelayMs = 0;
-    this.successfulFlushCount = 0;
-    this.failedFlushCount = 0;
-    this.deliveryAttemptCount = 0;
-    this.acceptedBatchCount = 0;
-    this.acceptedEventCount = 0;
-    this.lastStatusClass = "none";
-    this.lastAttemptAtUnixMs = 0;
-    this.lastAcceptedAtUnixMs = 0;
-    this.lastDroppedAtUnixMs = 0;
-    this.unacknowledgedBatch = undefined;
-    this.issueBreadcrumbs = [];
-    this.issueBreadcrumbsTruncated = false;
-    this.#scheduleAutomaticDelivery();
-  }
-
-  pendingEvents() {
-    return this.events.length;
-  }
-
-  pendingBytes() {
-    return this.queuedEventBytes;
-  }
-
-  droppedEvents() {
-    return this.droppedEventCount;
-  }
-
-  deliveryHealth() {
-    const droppedByReason = Object.freeze({ ...this.droppedEventsByReason });
-    return Object.freeze({
-      schemaVersion: DELIVERY_HEALTH_SCHEMA_VERSION,
-      automaticDelivery: this.automaticDelivery,
-      lifecycle: this.closed ? "closed" : this.closing ? "shutting_down" : "active",
-      deliveryState: this.#deliveryState(),
-      storage: this.storage,
-      queueEvents: this.events.length,
-      queueBytes: this.queuedEventBytes,
-      hydratedEvents: this.hydratedEventCount,
-      hydratedBytes: this.hydratedEventBytes,
-      droppedEvents: this.droppedEventCount,
-      droppedByReason,
-      lastDropReason: this.lastDropReason,
-      scheduled: this.deliveryTimer !== undefined,
-      inFlight: this.deliveryInFlight,
-      coalesced: this.automaticFlushPending,
-      pendingOperations: this.pendingOperations,
-      lastOutcome: this.lastDeliveryOutcome,
-      lastStatusClass: this.lastStatusClass,
-      pausedReason: this.automaticPauseReason,
-      consecutiveFailures: this.consecutiveDeliveryFailures,
-      retryDelayMs: this.retryDelayMs,
-      flushes: this.successfulFlushCount,
-      failures: this.failedFlushCount,
-      attempts: this.deliveryAttemptCount,
-      batches: this.acceptedBatchCount,
-      acceptedEvents: this.acceptedEventCount,
-      lastAttemptAtUnixMs: this.lastAttemptAtUnixMs,
-      lastAcceptedAtUnixMs: this.lastAcceptedAtUnixMs,
-      lastDroppedAtUnixMs: this.lastDroppedAtUnixMs
-    });
-  }
-
-  #deliveryState() {
-    if (this.deliveryInFlight) {
-      return "in_flight";
-    }
-    if (this.retryDelayMs > 0) {
-      return "retrying";
-    }
-    if (this.automaticPauseReason !== "none") {
-      return "paused";
-    }
-    if (this.events.length > 0) {
-      return this.deliveryTimer !== undefined ? "scheduled" : "queued";
-    }
-    if (this.lastDeliveryOutcome === "accepted") {
-      return "accepted";
-    }
-    if (this.lastDeliveryOutcome === "failed") {
-      return "failed";
-    }
-    if (this.droppedEventCount > 0) {
-      return "dropped";
-    }
-    return "idle";
-  }
-
-  previewJson() {
-    return JSON.stringify({ sdk: this.sdk, events: this.events }, null, 2);
-  }
-
-  purgePendingEvents() {
-    if (this.closed) {
-      throw new SdkError("shutdown_error", "client is already shut down");
-    }
-    if (this.closing) {
-      throw new SdkError("shutdown_error", "client is shutting down");
-    }
-    if (this.pendingOperations > 0 || this.automaticFlushActive) {
-      throw new SdkError("persistence_error", "cannot purge while a delivery operation is active");
-    }
-    const purgedEvents = this.events.length;
-    if (this.eventStore) {
-      requireSynchronousStoreResult("purge", this.eventStore.purge());
-    }
-    this.#clearDeliveryTimer();
-    this.automaticFlushPending = false;
-    this.unacknowledgedBatch = undefined;
-    this.events.splice(0, this.events.length);
-    this.serializedEvents.splice(0, this.serializedEvents.length);
-    this.serializedEventBytes.splice(0, this.serializedEventBytes.length);
-    this.queuedEventBytes = 0;
-    return purgedEvents;
-  }
-
-  addBreadcrumb(breadcrumb, timestamp = new Date().toISOString()) {
-    if (this.closed) {
-      throw new SdkError("shutdown_error", "client is already shut down");
-    }
-    if (this.closing) {
-      throw new SdkError("shutdown_error", "client is shutting down");
-    }
-    const validated = validateIssueBreadcrumb(breadcrumb, timestamp);
-    if (this.issueBreadcrumbs.length === MAX_ISSUE_BREADCRUMBS) {
-      this.issueBreadcrumbs.shift();
-      this.issueBreadcrumbsTruncated = true;
-    }
-    this.issueBreadcrumbs.push(validated);
-  }
-
-  clearBreadcrumbs() {
-    const cleared = this.issueBreadcrumbs.length;
-    this.issueBreadcrumbs.splice(0, cleared);
-    this.issueBreadcrumbsTruncated = false;
-    return cleared;
-  }
-
-  release(id, timestamp, attributes) {
-    this.#pushEvent("release", id, timestamp, validateRelease(attributes));
-  }
-
-  environment(id, timestamp, attributes) {
-    this.#pushEvent("environment", id, timestamp, validateEnvironment(attributes));
-  }
-
-  issue(id, timestamp, attributes) {
-    this.#pushIssue(id, timestamp, attributes);
-  }
-
-  issueWithAdmission(id, timestamp, attributes) {
-    const issue = this.issue;
-    if (issue !== LogBrewClient.#issueCapture) {
-      issue.call(this, id, timestamp, attributes);
-      return EVENT_ADMISSIONS.unavailable;
-    }
-    return this.#pushIssue(id, timestamp, attributes);
-  }
-
-  log(id, timestamp, attributes) {
-    this.#pushEvent("log", id, timestamp, validateLog(attributes));
-  }
-
-  span(id, timestamp, attributes) {
-    this.#pushEvent("span", id, timestamp, validateSpan(attributes));
-  }
-
-  action(id, timestamp, attributes) {
-    this.#pushEvent("action", id, timestamp, validateAction(attributes));
-  }
-
-  metric(id, timestamp, attributes) {
-    this.#pushEvent("metric", id, timestamp, validateMetric(attributes));
-  }
-
-  async flush(transport) {
-    if (this.closed) {
-      throw new SdkError("shutdown_error", "client is already shut down");
-    }
-    if (this.closing) {
-      throw new SdkError("shutdown_error", "client is shutting down");
-    }
-    const resolvedTransport = this.#resolveTransport(transport);
-    const controlsAutomaticDelivery = this.automaticDelivery && resolvedTransport === this.transport;
-    this.#clearDeliveryTimer();
-    return this.#runSerialized(async () => {
-      this.#clearDeliveryTimer();
-      try {
-        const response = await this.#flushWithHealth(resolvedTransport);
-        if (controlsAutomaticDelivery) {
-          this.#recordAutomaticSuccess();
-        }
-        return response;
-      } catch (error) {
-        if (controlsAutomaticDelivery) {
-          this.#recordAutomaticFailure(error);
-        }
-        throw error;
-      } finally {
-        if (this.automaticDelivery && !this.closed && !this.closing) {
-          this.#resumeAutomaticDelivery();
-        }
-      }
-    });
-  }
-
-  async shutdown(transport) {
-    if (this.closed) {
-      throw new SdkError("shutdown_error", "client is already shut down");
-    }
-    if (this.closing) {
-      throw new SdkError("shutdown_error", "client is shutting down");
-    }
-    const resolvedTransport = this.#resolveTransport(transport);
-    const controlsAutomaticDelivery = this.automaticDelivery && resolvedTransport === this.transport;
-    this.#clearDeliveryTimer();
-    this.automaticFlushPending = false;
-    this.closing = true;
-    try {
-      const response = await this.#runSerialized(() => this.#flushWithHealth(resolvedTransport));
-      if (controlsAutomaticDelivery) {
-        this.#recordAutomaticSuccess();
-      }
-      this.#saveClientReport(true);
-      if (this.eventStore) {
-        try {
-          requireSynchronousStoreResult("close", this.eventStore.close());
-        } catch (error) {
-          this.closed = true;
-          throw error;
-        }
-      }
-      this.closed = true;
-      return response;
-    } catch (error) {
-      if (!this.closed) {
-        this.closing = false;
-        if (controlsAutomaticDelivery) {
-          this.#recordAutomaticFailure(error);
-        }
-        this.#resumeAutomaticDelivery();
-      }
-      throw error;
-    }
-  }
-
-  #pushIssue(id, timestamp, attributes) {
-    if (attributes.breadcrumbs !== undefined) {
-      return this.#pushEvent("issue", id, timestamp, validateIssue(attributes));
-    }
-    const provided = this.#providedBreadcrumbs();
-    const merged = provided.breadcrumbs.length === 0
-      ? this.issueBreadcrumbs
-      : [...this.issueBreadcrumbs, ...provided.breadcrumbs]
-        .sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp));
-    const breadcrumbs = merged.slice(-MAX_ISSUE_BREADCRUMBS);
-    const truncated = attributes.breadcrumbsTruncated === true || this.issueBreadcrumbsTruncated
-      || provided.truncated || merged.length > breadcrumbs.length;
-    const withBreadcrumbs = breadcrumbs.length === 0
-      ? attributes
-      : { ...attributes, breadcrumbs, ...(truncated ? { breadcrumbsTruncated: true } : {}) };
-    return this.#pushEvent("issue", id, timestamp, validateIssue(withBreadcrumbs));
-  }
-
-  // Provider failures and invalid entries never cost the issue itself.
-  #providedBreadcrumbs() {
-    let provided;
-    try {
-      provided = this.breadcrumbProvider?.();
-    } catch {
-      return { breadcrumbs: [], truncated: false };
-    }
-    if (!provided || !Array.isArray(provided.breadcrumbs)) {
-      return { breadcrumbs: [], truncated: false };
-    }
-    const breadcrumbs = [];
-    let truncated = provided.truncated === true || provided.breadcrumbs.length > MAX_ISSUE_BREADCRUMBS;
-    for (const breadcrumb of provided.breadcrumbs.slice(-MAX_ISSUE_BREADCRUMBS)) {
-      try {
-        breadcrumbs.push(validateIssueBreadcrumb(breadcrumb));
-      } catch {
-        truncated = true;
-      }
-    }
-    return { breadcrumbs, truncated };
-  }
-
-  #pushEvent(eventType, id, timestamp, attributes) {
-    if (this.closed) {
-      throw new SdkError("shutdown_error", "client is already shut down");
-    }
-    if (this.closing) {
-      throw new SdkError("shutdown_error", "client is shutting down");
-    }
-    requireNonEmpty("event id", id);
-    requireTimestamp(timestamp);
-    const context = mergeTelemetryContexts(
-      mergeTelemetryContexts(this.context, this.contextProvider?.()),
-      attributes.context
-    );
-    const eventAttributes = context === undefined
-      ? attributes
-      : { ...attributes, context };
-    const event = { type: eventType, id, timestamp, attributes: eventAttributes };
-    if (this.eventFilter && this.eventFilter(cloneEvent(event)) === false) {
-      return EVENT_ADMISSIONS.filtered;
-    }
-    const serializedEvent = JSON.stringify(event);
-    const eventBytes = utf8ByteLength(serializedEvent);
-    if (this.batchPrefixBytes + eventBytes + this.batchSuffixBytes > this.maxBatchBytes) {
-      this.#recordDroppedEvent(event, "event_too_large");
-      return EVENT_ADMISSIONS.event_too_large;
-    }
-    const fatal = isFatalEvent(event);
-    if (fatal) {
-      this.#synchronizeEventStore();
-    }
-    const overflow = this.#overflowReason(this.events.length, this.queuedEventBytes + eventBytes);
-    const evicted = overflow && fatal ? this.#evictForFatal(eventBytes) : [];
-    if (overflow && evicted.length === 0) {
-      this.#recordDroppedEvent(event, overflow);
-      return EVENT_ADMISSIONS[overflow];
-    }
-    try {
-      if (this.eventStore) {
-        requireSynchronousStoreResult("append", this.eventStore.append({
-          event: cloneEvent(event),
-          eventBytes,
-          serializedEvent
-        }));
-      }
-      this.events.push(event);
-      this.serializedEvents.push(serializedEvent);
-      this.serializedEventBytes.push(eventBytes);
-      this.queuedEventBytes += eventBytes;
-    } finally {
-      // Report evictions only after admission so drop callbacks cannot refill the freed room.
-      for (const evictedEvent of evicted) {
-        this.#recordDroppedEvent(evictedEvent, "evicted_for_fatal");
-      }
-    }
-    this.#scheduleAutomaticDelivery();
-    return EVENT_ADMISSIONS.admitted;
-  }
-
-  #overflowReason(count, bytes) {
-    if (count >= this.maxQueueSize) {
-      return "queue_overflow";
-    }
-    return bytes > this.maxQueueBytes ? "queue_bytes_overflow" : undefined;
-  }
-
-  // Evicts the oldest non-fatal events outside the unacknowledged batch, only when that makes room.
-  #evictForFatal(eventBytes) {
-    if (this.eventStore && typeof this.eventStore.remove !== "function") {
-      return [];
-    }
-    const indexes = [];
-    let count = this.events.length;
-    let bytes = this.queuedEventBytes + eventBytes;
-    for (
-      let index = this.unacknowledgedBatch?.eventsCount ?? 0;
-      index < this.events.length && this.#overflowReason(count, bytes);
-      index += 1
-    ) {
-      if (!isFatalEvent(this.events[index])) {
-        indexes.push(index);
-        count -= 1;
-        bytes -= this.serializedEventBytes[index];
-      }
-    }
-    if (this.#overflowReason(count, bytes)) {
-      return [];
-    }
-    if (this.eventStore) {
-      requireSynchronousStoreResult("remove", this.eventStore.remove(indexes));
-    }
-    const evicted = indexes.map((index) => this.events[index]);
-    for (let position = indexes.length - 1; position >= 0; position -= 1) {
-      const index = indexes[position];
-      this.events.splice(index, 1);
-      this.serializedEvents.splice(index, 1);
-      this.queuedEventBytes -= this.serializedEventBytes.splice(index, 1)[0];
-    }
-    return evicted;
-  }
-
-  #recordDroppedEvent(event, reason) {
-    this.droppedEventCount = incrementBounded(this.droppedEventCount);
-    this.droppedEventsByReason[reason] = incrementBounded(this.droppedEventsByReason[reason]);
-    const firstOfReason = this.unreportedDropsByReason[reason] === undefined;
-    this.unreportedDropsByReason[reason] = Math.min(MAX_CLIENT_REPORT_COUNT, (this.unreportedDropsByReason[reason] ?? 0) + 1);
-    this.#saveClientReport(firstOfReason);
-    this.lastDropReason = reason;
-    this.lastDroppedAtUnixMs = nextBoundedTimestamp(this.lastDroppedAtUnixMs);
-    if (!this.onEventDropped) {
-      return;
-    }
-    try {
-      this.onEventDropped({
-        droppedEvents: this.droppedEventCount,
-        eventId: event.id,
-        eventType: event.type,
-        reason
-      });
-    } catch {
-      // Drop callbacks are advisory and must not interrupt application logging.
-    }
-  }
-
-  #runSerialized(operation) {
-    this.pendingOperations = incrementBounded(this.pendingOperations);
-    const result = this.operationTail.then(operation).finally(() => {
-      this.pendingOperations = Math.max(0, this.pendingOperations - 1);
-    });
-    this.operationTail = result.then(
-      () => undefined,
-      () => undefined
-    );
-    return result;
-  }
-
-  #resolveTransport(transport) {
-    const resolved = transport ?? this.transport;
-    if (resolved === undefined) {
-      throw new SdkError("validation_error", "flush and shutdown require transport");
-    }
-    validateTransport(resolved);
-    return resolved;
-  }
-
-  async #flushWithHealth(transport) {
-    this.deliveryInFlight = true;
-    try {
-      const response = await this.#flushSnapshot(transport);
-      this.successfulFlushCount = incrementBounded(this.successfulFlushCount);
-      this.lastDeliveryOutcome = response.batches === 0 ? "empty" : "accepted";
-      return response;
-    } catch (error) {
-      this.failedFlushCount = incrementBounded(this.failedFlushCount);
-      this.lastDeliveryOutcome = "failed";
-      throw error;
-    } finally {
-      this.deliveryInFlight = false;
-    }
-  }
-
-  #scheduleAutomaticDelivery() {
-    if (!this.automaticDelivery || this.closed || this.closing || this.events.length === 0 || this.automaticPauseReason !== "none") {
-      return;
-    }
-    if (this.automaticFlushActive) {
-      this.automaticFlushPending = true;
-      return;
-    }
-    if (this.retryDelayMs > 0) {
-      this.#armAutomaticDeliveryTimer(this.retryDelayMs);
-      return;
-    }
-    if (this.events.length >= this.deliveryQueueThreshold) {
-      this.#requestAutomaticFlush();
-      return;
-    }
-    this.#armAutomaticDeliveryTimer();
-  }
-
-  #armAutomaticDeliveryTimer(delayMs = this.deliveryIntervalMs) {
-    if (!this.automaticDelivery || this.closed || this.closing || this.events.length === 0 || this.automaticPauseReason !== "none") {
-      return;
-    }
-    if (this.deliveryTimer !== undefined) {
-      return;
-    }
-    const timer = setTimeout(() => {
-      if (this.deliveryTimer !== timer) {
-        return;
-      }
-      this.deliveryTimer = undefined;
-      this.retryDelayMs = 0;
-      this.#requestAutomaticFlush();
-    }, delayMs);
-    this.deliveryTimer = timer;
-    if (timer && typeof timer === "object" && typeof timer.unref === "function") {
-      timer.unref();
-    }
-  }
-
-  #clearDeliveryTimer() {
-    if (this.deliveryTimer === undefined) {
-      return;
-    }
-    globalThis.clearTimeout(this.deliveryTimer);
-    this.deliveryTimer = undefined;
-  }
-
-  #requestAutomaticFlush() {
-    if (!this.automaticDelivery || this.closed || this.closing || this.events.length === 0 || this.automaticPauseReason !== "none") {
-      return;
-    }
-    this.#clearDeliveryTimer();
-    if (this.automaticFlushActive) {
-      this.automaticFlushPending = true;
-      return;
-    }
-    this.automaticFlushActive = true;
-    void Promise.resolve().then(() => this.#runAutomaticFlush());
-  }
-
-  async #runAutomaticFlush() {
-    if (this.closed || this.closing) {
-      this.automaticFlushActive = false;
-      this.automaticFlushPending = false;
-      return;
-    }
-    let succeeded = false;
-    try {
-      await this.#runSerialized(() => this.#flushWithHealth(this.transport));
-      this.#recordAutomaticSuccess();
-      succeeded = true;
-    } catch (error) {
-      this.#recordAutomaticFailure(error);
-    } finally {
-      this.automaticFlushActive = false;
-      if (this.closed || this.closing) {
-        this.automaticFlushPending = false;
-      } else {
-        const drainCoalesced = succeeded && this.automaticFlushPending && this.events.length > 0;
-        this.automaticFlushPending = false;
-        if (drainCoalesced) {
-          this.#requestAutomaticFlush();
-        } else if (!succeeded) {
-          this.#resumeAutomaticDelivery();
-        } else {
-          this.#scheduleAutomaticDelivery();
-        }
-      }
-    }
-  }
-
-  async #flushSnapshot(transport) {
-    this.#synchronizeEventStore();
-    let remainingEvents = this.events.length;
-    if (remainingEvents === 0) {
-      return { statusCode: 204, attempts: 0, batches: 0 };
-    }
-
-    let attempts = 0;
-    let batches = 0;
-    let statusCode = 204;
-    while (remainingEvents > 0) {
-      // Eviction for a fatal event can shrink the snapshot while a batch is in flight.
-      this.unacknowledgedBatch ??= Object.freeze(
-        this.#nextBatch(Math.min(remainingEvents, this.events.length, this.maxBatchEvents))
-      );
-      const batch = this.unacknowledgedBatch;
-      const response = await this.#sendBatch(transport, batch.body);
-      this.unacknowledgedBatch = undefined;
-      // Drops recorded while this body was in flight stay pending under a new report ID.
-      if (batch.carriesClientReport) {
-        this.pendingClientReport = undefined;
-        this.#saveClientReport(true);
-      }
-      this.#acknowledge(batch.eventsCount);
-      this.acceptedBatchCount = incrementBounded(this.acceptedBatchCount);
-      remainingEvents -= batch.eventsCount;
-      attempts += response.attempts;
-      batches += 1;
-      statusCode = response.statusCode;
-    }
-
-    return { statusCode, attempts, batches };
-  }
-
-  #synchronizeEventStore() {
-    if (!this.eventStore) {
-      return;
-    }
-    const recovered = loadStoredEvents(this);
-    if (!isOrderedSubsequence(this.serializedEvents, recovered.serializedEvents)) {
-      throw new SdkError("persistence_error", "event store lost a queued record");
-    }
-    this.events = recovered.events;
-    this.serializedEvents = recovered.serializedEvents;
-    this.serializedEventBytes = recovered.serializedEventBytes;
-    this.queuedEventBytes = recovered.queuedEventBytes;
-  }
-
-  #nextBatch(maxEvents) {
-    const report = this.#pendingClientReport();
-    const reportSuffix = report && `],"client_report":${JSON.stringify(report)}}`;
-    const reportedEvents = reportSuffix ? this.#batchEventCount(maxEvents, utf8ByteLength(reportSuffix)) : 0;
-    const eventsCount = reportedEvents || this.#batchEventCount(maxEvents, this.batchSuffixBytes);
-    if (eventsCount === 0) {
-      throw new SdkError("transport_error", "queued event cannot fit the configured batch byte limit");
-    }
-    return {
-      body: `${this.batchPrefix}${this.serializedEvents.slice(0, eventsCount).join(",")}${reportedEvents ? reportSuffix : this.batchSuffix}`,
-      carriesClientReport: reportedEvents > 0,
-      eventsCount
-    };
-  }
-
-  // Freezes unreported drops under one stable ID, so every resend of them is counted once.
-  #pendingClientReport() {
-    if (this.pendingClientReport === undefined) {
-      const reported = Object.entries(this.unreportedDropsByReason).filter(([, count]) => count > 0);
-      if (reported.length === 0) {
-        return undefined;
-      }
-      const droppedEvents = Object.fromEntries(reported.slice(0, MAX_CLIENT_REPORT_REASONS));
-      for (const reason of Object.keys(droppedEvents)) {
-        delete this.unreportedDropsByReason[reason];
-      }
-      this.pendingClientReport = Object.freeze({ report_id: randomHex(16), dropped_events: droppedEvents });
-      this.#saveClientReport(true);
-    }
-    return this.pendingClientReport;
-  }
-
-  // Saves at once for a new report or reason, and at most once a second during a drop burst.
-  #saveClientReport(immediately) {
-    const now = Date.now();
-    if (!this.clientReportStore || (!immediately && now - this.clientReportSavedAtMs < CLIENT_REPORT_SAVE_INTERVAL_MS)) {
-      return;
-    }
-    this.clientReportSavedAtMs = now;
-    try {
-      requireSynchronousStoreResult("saveClientReport", this.clientReportStore.saveClientReport({
-        pending: this.pendingClientReport ?? null,
-        unreported: { ...this.unreportedDropsByReason }
-      }));
-    } catch {
-      // Drop counts are advisory: a failed save keeps them in memory and never blocks capture.
-    }
-  }
-
-  #batchEventCount(maxEvents, suffixBytes) {
-    let bodyBytes = this.batchPrefixBytes + suffixBytes;
-    let eventsCount = 0;
-    const eventIds = new Set();
-    for (let index = 0; index < maxEvents; index += 1) {
-      if (eventIds.has(this.events[index].id)) {
-        break;
-      }
-      const separatorBytes = eventsCount === 0 ? 0 : 1;
-      const nextBodyBytes = bodyBytes + separatorBytes + this.serializedEventBytes[index];
-      if (nextBodyBytes > this.maxBatchBytes) {
-        break;
-      }
-      eventIds.add(this.events[index].id);
-      bodyBytes = nextBodyBytes;
-      eventsCount += 1;
-    }
-    return eventsCount;
-  }
-
-  #acknowledge(eventsCount) {
-    if (this.eventStore) {
-      requireSynchronousStoreResult("acknowledge", this.eventStore.acknowledge(eventsCount));
-    }
-    let acknowledgedBytes = 0;
-    for (let index = 0; index < eventsCount; index += 1) {
-      acknowledgedBytes += this.serializedEventBytes[index];
-    }
-    this.events.splice(0, eventsCount);
-    this.serializedEvents.splice(0, eventsCount);
-    this.serializedEventBytes.splice(0, eventsCount);
-    this.queuedEventBytes -= acknowledgedBytes;
-    this.acceptedEventCount = addBounded(this.acceptedEventCount, eventsCount);
-    this.lastAcceptedAtUnixMs = nextBoundedTimestamp(Math.max(
-      this.lastAcceptedAtUnixMs,
-      this.lastAttemptAtUnixMs
-    ));
-  }
-
-  #recordAutomaticSuccess() {
-    this.automaticPauseReason = "none";
-    this.consecutiveDeliveryFailures = 0;
-    this.retryDelayMs = 0;
-  }
-
-  #recordAutomaticFailure(error) {
-    this.consecutiveDeliveryFailures = incrementBounded(this.consecutiveDeliveryFailures);
-    this.retryDelayMs = 0;
-    if (error instanceof SdkError && error.code === "unauthenticated") {
-      this.automaticPauseReason = "authentication";
-      return;
-    }
-    if (error instanceof SdkError && error.code === "rate_limited") {
-      if (error.retryable === true) {
-        this.automaticPauseReason = "none";
-        this.retryDelayMs = rateLimitWaitMs(
-          error.retryAfterMs ?? automaticRetryDelayMs(this.deliveryIntervalMs, this.consecutiveDeliveryFailures)
-        );
-        return;
-      }
-      this.automaticPauseReason = "rate_limit";
-      return;
-    }
-    if (error instanceof SdkError && error.retryable === true) {
-      this.automaticPauseReason = "none";
-      this.retryDelayMs = automaticRetryDelayMs(this.deliveryIntervalMs, this.consecutiveDeliveryFailures);
-      return;
-    }
-    this.automaticPauseReason = "non_retryable";
-  }
-
-  #resumeAutomaticDelivery() {
-    if (this.automaticPauseReason !== "none") {
-      return;
-    }
-    if (this.retryDelayMs > 0) {
-      this.#armAutomaticDeliveryTimer(this.retryDelayMs);
-      return;
-    }
-    this.#scheduleAutomaticDelivery();
-  }
-
-  async #sendBatch(transport, body) {
-    const maxAttempts = this.maxRetries + 1;
-    let attempts = 0;
-
-    while (attempts < maxAttempts) {
-      attempts += 1;
-      this.deliveryAttemptCount = incrementBounded(this.deliveryAttemptCount);
-      this.lastAttemptAtUnixMs = nextBoundedTimestamp(this.lastAttemptAtUnixMs);
-      this.lastStatusClass = "transport_error";
-      try {
-        const response = await transport.send(this.apiKey, body);
-        if (
-          !response
-          || Array.isArray(response)
-          || typeof response !== "object"
-          || !Number.isSafeInteger(response.statusCode)
-          || response.statusCode < 100
-          || response.statusCode > 599
-        ) {
-          this.lastStatusClass = "invalid_response";
-          throw new SdkError("transport_error", "invalid transport response");
-        }
-        this.lastStatusClass = statusClass(response.statusCode);
-        if (response.statusCode === 401) {
-          throw new SdkError("unauthenticated", "transport rejected the API key");
-        }
-        if (response.statusCode === 429) {
-          throw new SdkError("rate_limited", "transport rate limited the batch", {
-            retryAfterMs: response.retryAfterMs,
-            retryable: response.errorCode !== "usage_limit_exceeded"
-              && (retryAfterMsOrUndefined(response.retryAfterMs) !== undefined || response.errorCode === "rate_limited")
-          });
-        }
-        if (response.statusCode >= 200 && response.statusCode < 300) {
-          return { statusCode: response.statusCode, attempts };
-        }
-        const retryableStatus = response.statusCode === 408 || response.statusCode >= 500;
-        if (retryableStatus && attempts < maxAttempts) {
-          continue;
-        }
-        throw new SdkError("transport_error", `unexpected transport status ${response.statusCode}`, {
-          retryable: retryableStatus
-        });
-      } catch (error) {
-        if (error instanceof SdkError) {
-          throw error;
-        }
-        if (error instanceof TransportError && error.retryable && attempts < maxAttempts) {
-          this.lastStatusClass = "network_error";
-          continue;
-        }
-        if (error instanceof TransportError) {
-          this.lastStatusClass = "network_error";
-          throw new SdkError(error.code, error.message, { retryable: error.retryable });
-        }
-        throw error;
-      }
-    }
-
-    throw new SdkError("transport_error", "exhausted retries");
-  }
-}
-
-function automaticRetryDelayMs(deliveryIntervalMs, consecutiveFailures) {
-  const exponent = Math.min(consecutiveFailures - 1, 30);
-  const maximumDelay = Math.min(MAX_DELIVERY_INTERVAL_MS, deliveryIntervalMs * (2 ** exponent));
-  const minimumDelay = Math.ceil(maximumDelay / 2);
-  return minimumDelay + Math.floor(Math.random() * (maximumDelay - minimumDelay + 1));
-}
-
-function rateLimitWaitMs(delayMs) {
-  const bounded = Math.min(MAX_RATE_LIMIT_WAIT_MS, Math.max(MIN_RATE_LIMIT_WAIT_MS, delayMs));
-  return Math.min(MAX_RATE_LIMIT_WAIT_MS, bounded + Math.floor(Math.random() * (Math.floor(bounded / 10) + 1)));
-}
-
-function statusClass(statusCode) {
-  if (statusCode >= 200 && statusCode < 300) {
-    return "success";
-  }
-  if (statusCode >= 400 && statusCode < 500) {
-    return "client_error";
-  }
-  if (statusCode >= 500) {
-    return "server_error";
-  }
-  return "other_status";
-}
-
-function nextBoundedTimestamp(previous) {
-  const now = Date.now();
-  if (!Number.isFinite(now)) {
-    return previous;
-  }
-  const bounded = Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(now)));
-  return Math.max(previous, bounded);
-}
-
-function addBounded(current, increment) {
-  return Math.min(Number.MAX_SAFE_INTEGER, current + increment);
-}
-
-function utf8ByteLength(value) {
-  let bytes = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const codeUnit = value.charCodeAt(index);
-    if (codeUnit < 0x80) {
-      bytes += 1;
-    } else if (codeUnit < 0x800) {
-      bytes += 2;
-    } else if (codeUnit >= 0xd800 && codeUnit <= 0xdbff && index + 1 < value.length) {
-      const nextCodeUnit = value.charCodeAt(index + 1);
-      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {
-        bytes += 4;
-        index += 1;
-      } else {
-        bytes += 3;
-      }
-    } else {
-      bytes += 3;
-    }
-  }
-  return bytes;
-}
-
-// Fatal input severity is stored as critical; a critical issue is a crash report.
-function isFatalEvent(event) {
-  return event.type === "issue" && event.attributes.level === "critical";
-}
-
-// Report IDs only need uniqueness, so runtimes without Web Crypto fall back to Math.random.
-function randomHex(byteLength) {
-  const bytes = new Uint8Array(byteLength);
-  if (typeof globalThis.crypto?.getRandomValues === "function") {
-    globalThis.crypto.getRandomValues(bytes);
-  } else {
-    for (let index = 0; index < bytes.length; index += 1) {
-      bytes[index] = Math.floor(Math.random() * 256);
-    }
-  }
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-
-function isClientReportStore(store) {
-  return typeof store?.loadClientReport === "function" && typeof store.saveClientReport === "function";
-}
-
-// Restores saved drop counts; anything unreadable or out of bounds is ignored, never fatal.
-function loadClientReport(store) {
-  let state;
-  try {
-    state = store ? requireSynchronousStoreResult("loadClientReport", store.loadClientReport()) : undefined;
-  } catch {
-    state = undefined;
-  }
-  const pending = state?.pending;
-  const pendingCounts = validClientReportCounts(pending?.dropped_events);
-  return {
-    pending: CLIENT_REPORT_ID_PATTERN.test(pending?.report_id ?? "") && Object.keys(pendingCounts).length > 0
-      ? Object.freeze({ report_id: pending.report_id, dropped_events: pendingCounts })
-      : undefined,
-    unreported: validClientReportCounts(state?.unreported)
-  };
-}
-
-function validClientReportCounts(counts) {
-  if (!counts || typeof counts !== "object" || Array.isArray(counts)) {
-    return {};
-  }
-  return Object.fromEntries(Object.entries(counts).filter(([reason, count]) => (
-    CLIENT_REPORT_REASON_PATTERN.test(reason) && Number.isSafeInteger(count) && count >= 1 && count <= MAX_CLIENT_REPORT_COUNT
-  )).slice(0, MAX_CLIENT_REPORT_REASONS));
-}
-
-function incrementBounded(value) {
-  return value >= Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : value + 1;
-}
-
-function validateTransport(transport) {
-  if (transport === undefined) {
-    return;
-  }
-  if (!transport || Array.isArray(transport) || typeof transport !== "object" || typeof transport.send !== "function") {
-    throw new SdkError("validation_error", "transport.send must be a function");
-  }
-}
-
-function validateEventStore(eventStore) {
-  if (eventStore === undefined) {
-    return;
-  }
-  if (!eventStore || Array.isArray(eventStore) || typeof eventStore !== "object") {
-    throw new SdkError("validation_error", "eventStore must be an object");
-  }
-  for (const method of ["load", "append", "acknowledge", "purge", "close"]) {
-    if (typeof eventStore[method] !== "function") {
-      throw new SdkError("validation_error", `eventStore.${method} must be a function`);
-    }
-  }
-}
-
-function createEventStoreFromQueueFactory(eventQueueFactory, config) {
-  const queue = eventQueueFactory({
-    ...config,
-    restoreEvent: restoreStoredEvent
-  });
-  validateEventQueue(queue);
-  const eventStore = {
-    load() {
-      const events = queue.events();
-      const count = queue.length();
-      if (!Array.isArray(events) || events.length !== count) {
-        throw invalidStoredRecord();
-      }
-      return events.map((event, index) => ({
-        event,
-        eventBytes: queue.eventBytesAt(index),
-        serializedEvent: queue.serializedAt(index)
-      }));
-    },
-    append(record) {
-      return queue.append({
-        event: record.event,
-        byteCount: record.eventBytes,
-        serialized: record.serializedEvent
-      });
-    },
-    acknowledge(count) {
-      return queue.acknowledge(count);
-    },
-    purge() {
-      return queue.acknowledge(queue.length());
-    },
-    close() {
-      return queue.close();
-    }
-  };
-  if (typeof queue.remove === "function") {
-    eventStore.remove = (indexes) => queue.remove(indexes);
-  }
-  if (isClientReportStore(queue)) {
-    eventStore.loadClientReport = () => queue.loadClientReport();
-    eventStore.saveClientReport = (state) => queue.saveClientReport(state);
-  }
-  return eventStore;
-}
-
-function validateEventQueue(queue) {
-  const methods = [
-    "acknowledge",
-    "append",
-    "byteCount",
-    "close",
-    "eventBytesAt",
-    "events",
-    "length",
-    "serializedAt"
-  ];
-  if (!queue || Array.isArray(queue) || typeof queue !== "object" || methods.some((method) => typeof queue[method] !== "function")) {
-    throw new SdkError("validation_error", "event queue factory returned an invalid queue");
-  }
-}
-
-function restoreStoredEvent(serializedEvent) {
-  if (typeof serializedEvent !== "string" || serializedEvent === "") {
-    throw invalidStoredRecord();
-  }
-  let event;
-  try {
-    event = JSON.parse(serializedEvent);
-  } catch {
-    throw invalidStoredRecord();
-  }
-  return normalizeStoredRecord({
-    event,
-    eventBytes: utf8ByteLength(serializedEvent),
-    serializedEvent
-  }).event;
-}
-
-function requireSynchronousStoreResult(operation, result) {
-  if (result && typeof result.then === "function") {
-    throw new SdkError("persistence_error", `eventStore.${operation} must complete synchronously`);
-  }
-  return result;
-}
-
-function loadStoredEvents({
-  batchPrefixBytes,
-  batchSuffixBytes,
-  eventStore,
-  maxBatchBytes,
-  maxQueueBytes,
-  maxQueueSize
-}) {
-  if (!eventStore) {
-    return {
-      events: [],
-      queuedEventBytes: 0,
-      serializedEventBytes: [],
-      serializedEvents: []
-    };
-  }
-
-  const records = requireSynchronousStoreResult("load", eventStore.load());
-  if (!Array.isArray(records)) {
-    throw invalidStoredRecord();
-  }
-  if (records.length > maxQueueSize) {
-    throw new SdkError("persistence_error", "recovered event count exceeds maxQueueSize");
-  }
-
-  const events = [];
-  const serializedEvents = [];
-  const serializedEventBytes = [];
-  let queuedEventBytes = 0;
-  for (const record of records) {
-    const normalized = normalizeStoredRecord(record);
-    if (batchPrefixBytes + normalized.eventBytes + batchSuffixBytes > maxBatchBytes) {
-      throw new SdkError("persistence_error", "recovered event exceeds maxBatchBytes");
-    }
-    queuedEventBytes += normalized.eventBytes;
-    if (queuedEventBytes > maxQueueBytes) {
-      throw new SdkError("persistence_error", "recovered event bytes exceed maxQueueBytes");
-    }
-    events.push(normalized.event);
-    serializedEvents.push(normalized.serializedEvent);
-    serializedEventBytes.push(normalized.eventBytes);
-  }
-  return { events, queuedEventBytes, serializedEventBytes, serializedEvents };
-}
-
-function isOrderedSubsequence(expected, actual) {
-  let index = 0;
-  for (const value of actual) {
-    index += value === expected[index] ? 1 : 0;
-  }
-  return index === expected.length;
-}
-
-function structuralJson(value) {
-  return JSON.stringify(value, (_, entry) => entry && !Array.isArray(entry) && typeof entry === "object"
-    ? Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right))) : entry);
-}
-
-function normalizeStoredRecord(record) {
-  try {
-    if (!record || Array.isArray(record) || typeof record !== "object") {
-      throw invalidStoredRecord();
-    }
-    const { event, eventBytes, serializedEvent } = record;
-    if (!event || Array.isArray(event) || typeof event !== "object") {
-      throw invalidStoredRecord();
-    }
-    const validator = EVENT_VALIDATORS.get(event.type);
-    if (!validator || !Number.isSafeInteger(eventBytes) || eventBytes <= 0 || typeof serializedEvent !== "string") {
-      throw invalidStoredRecord();
-    }
-    requireNonEmpty("event id", event.id);
-    requireTimestamp(event.timestamp);
-    if (!event.attributes || Array.isArray(event.attributes) || typeof event.attributes !== "object") {
-      throw invalidStoredRecord();
-    }
-    if (JSON.stringify(event) !== serializedEvent || utf8ByteLength(serializedEvent) !== eventBytes) {
-      throw invalidStoredRecord();
-    }
-    const recoveredAttributes = event.type === "issue" && event.attributes.level === "fatal"
-      ? { ...event.attributes, level: "critical" }
-      : event.attributes;
-    const context = recoveredAttributes.context;
-    const recoveredEvent = context && !Array.isArray(context) && typeof context === "object"
-      && context.schemaVersion === undefined
-      ? { ...event, attributes: { ...recoveredAttributes, context: { schemaVersion: 1, ...context } } }
-      : { ...event, attributes: recoveredAttributes };
-    const normalizedEvent = {
-      type: recoveredEvent.type,
-      id: recoveredEvent.id,
-      timestamp: recoveredEvent.timestamp,
-      attributes: validator(recoveredEvent.attributes)
-    };
-    const normalizedSerializedEvent = JSON.stringify(normalizedEvent);
-    if (structuralJson(normalizedEvent) !== structuralJson(recoveredEvent)) {
-      throw invalidStoredRecord();
-    }
-    return {
-      event: cloneEvent(normalizedEvent),
-      eventBytes: utf8ByteLength(normalizedSerializedEvent),
-      serializedEvent: normalizedSerializedEvent
-    };
-  } catch (error) {
-    if (error instanceof SdkError && error.code === "persistence_error") {
-      throw error;
-    }
-    throw invalidStoredRecord();
-  }
-}
-
-function invalidStoredRecord() {
-  return new SdkError("persistence_error", "event store returned an invalid record");
-}
-
-function installLogBrewConsoleCapture(config) {
-  if (!config || typeof config !== "object") {
-    throw new SdkError("validation_error", "console capture config must be an object");
-  }
-
-  const client = config.client;
-  if (!(client instanceof LogBrewClient)) {
-    throw new SdkError("validation_error", "console capture client must be a LogBrewClient");
-  }
-
-  const targetConsole = config.console ?? globalThis.console;
-  if (!targetConsole || typeof targetConsole !== "object") {
-    throw new SdkError("validation_error", "console capture target must be an object");
-  }
-
-  const transport = config.transport;
-  const flushOnCapture = config.flushOnCapture === true;
-  const includeErrorStack = config.includeErrorStack === true;
-  const logger = config.logger ?? "console";
-  const metadata = compactMetadata(config.metadata);
-  const timestamp = typeof config.timestamp === "function"
-    ? config.timestamp
-    : () => new Date().toISOString();
-  const eventIdPrefix = config.eventIdPrefix ?? "console";
-  const onError = typeof config.onError === "function" ? config.onError : () => {};
-  const levels = normalizeConsoleLevels(config.levels);
-  const originals = new Map();
-  const state = {
-    installed: true,
-    captured: 0,
-    pendingFlush: Promise.resolve(null)
-  };
-
-  for (const method of levels) {
-    const original = targetConsole[method];
-    if (typeof original !== "function") {
-      continue;
-    }
-    originals.set(method, original);
-    targetConsole[method] = createConsoleCaptureMethod({
-      client,
-      eventIdPrefix,
-      flushOnCapture,
-      includeErrorStack,
-      logger,
-      metadata,
-      method,
-      onError,
-      original,
-      state,
-      timestamp,
-      transport
-    });
-  }
-
-  return {
-    async flush() {
-      if (transport && client.pendingEvents() > 0) {
-        state.pendingFlush = Promise.resolve(client.flush(transport)).catch((error) => {
-          onError(error);
-          return null;
-        });
-      }
-      return state.pendingFlush;
-    },
-    uninstall() {
-      if (!state.installed) {
-        return;
-      }
-      state.installed = false;
-      for (const [method, original] of originals.entries()) {
-        targetConsole[method] = original;
-      }
-      originals.clear();
-    }
-  };
-}
-
-function createConsoleCaptureMethod(config) {
-  /** @this {*} */
-  return function logBrewConsoleMethod(...args) {
-    config.original.apply(this, args);
-    if (!config.state.installed) {
-      return;
-    }
-    try {
-      config.state.captured += 1;
-      config.client.log(
-        `${config.eventIdPrefix}_${config.state.captured}`,
-        config.timestamp(),
-        logAttributesFromConsoleArgs(config.method, args, {
-          includeErrorStack: config.includeErrorStack,
-          logger: config.logger,
-          metadata: config.metadata
-        })
-      );
-      if (config.flushOnCapture && config.transport) {
-        config.state.pendingFlush = Promise.resolve(config.client.flush(config.transport)).catch((error) => {
-          config.onError(error);
-          return null;
-        });
-      }
-    } catch (error) {
-      config.onError(error);
-    }
-  };
-}
-
-function logAttributesFromConsoleArgs(method, args, options = {}) {
-  const logLevel = logbrewLevelFromConsoleMethod(method);
-  const includeErrorStack = options.includeErrorStack === true;
-  const message = consoleMessage(args, includeErrorStack);
-  const metadata = {
-    ...compactMetadata(options.metadata),
-    consoleMethod: method,
-    argumentCount: Array.isArray(args) ? args.length : 0
-  };
-  for (const value of Array.isArray(args) ? args : []) {
-    if (value instanceof Error) {
-      metadata.errorName = value.name || "Error";
-      if (value.message) {
-        metadata.errorMessage = value.message;
-      }
-      if (includeErrorStack && value.stack) {
-        metadata.errorStack = value.stack;
-      }
-      break;
-    }
-  }
-
-  return {
-    message,
-    level: logLevel,
-    ...(options.logger ? { logger: options.logger } : {}),
-    metadata
-  };
-}
-
-function createIssueAttributesFromError(error, options = {}) {
-  if (!options || Array.isArray(options) || typeof options !== "object") {
-    throw new SdkError("validation_error", "error issue options must be an object");
-  }
-  const details = errorDetails(error);
-  const stackEvidence = javascriptStackEvidence(details.stack, options.debugIdMap);
-  const stackFrames = stackEvidence.frames;
-  const frame = stackFrames[0] ?? null;
-  const source = stringOrUndefined(options.source) ?? "javascript.error";
-  const metadata = {
-    ...compactMetadata(options.metadata),
-    source,
-    errorName: details.name,
-    ...(details.message ? { errorMessage: details.message } : {}),
-    ...(frame ? {
-      errorFrameFile: frame.filename,
-      errorFrameLine: frame.line,
-      errorFrameColumn: frame.column
-    } : {}),
-    ...issueGroupingMetadata(source, details, frame, options.fingerprint),
-    ...errorCauseMetadata(error),
-    ...(stringOrUndefined(options.release) ? { release: options.release } : {}),
-    ...(stringOrUndefined(options.environment) ? { environment: options.environment } : {}),
-    ...(stringOrUndefined(options.service) ? { service: options.service } : {}),
-    ...(stringOrUndefined(options.runtime) ? { runtime: options.runtime } : {}),
-    ...(stringOrUndefined(options.platform) ? { platform: options.platform } : {}),
-    ...traceMetadata(options.trace),
-    ...releaseArtifactMetadata(frame),
-    ...(options.includeErrorStack === true && details.stack ? { errorStack: details.stack } : {})
-  };
-
-  const exception = createIssueException(
-    boundedIssueExceptionType(details.name),
-    stringOrUndefined(options.mechanism) ?? "javascript.error",
-    options.handled === undefined ? true : options.handled
-  );
-  const exceptionChain = createJavaScriptExceptionChain(error, {
-    details,
-    exception,
-    stackEvidence,
-    debugIdMap: options.debugIdMap
-  });
-  return {
-    title: stringOrUndefined(options.title) ?? details.name,
-    level: normalizeSeverity("issue level", options.level ?? "error"),
-    ...(stringOrUndefined(options.message) ? { message: options.message } : details.message ? { message: details.message } : {}),
-    exception,
-    exceptionChain,
-    ...(stackFrames.length > 0 ? { stackFrames } : {}),
-    ...(options.evidence === undefined ? {} : { evidence: validateIssueEvidence(options.evidence) }),
-    metadata: compactMetadata(metadata)
-  };
-}
-
-function createJavaScriptExceptionChain(error, root) {
-  const state = {
-    entries: [],
-    seen: new Set(),
-    truncated: false,
-    debugIdMap: root.debugIdMap
-  };
-  if (isObjectLike(error)) {
-    state.seen.add(error);
-  }
-  appendJavaScriptExceptionNode(error, undefined, "reported", state, root);
-  collectJavaScriptExceptionChildren(error, 0, state);
-  return { entries: state.entries, truncated: state.truncated };
-}
-
-function appendJavaScriptExceptionNode(value, parentId, relationship, state, known = undefined) {
-  if (state.entries.length >= 8) {
-    state.truncated = true;
-    return undefined;
-  }
-  const details = known?.details ?? errorDetails(value);
-  const stackEvidence = known?.stackEvidence
-    ?? javascriptStackEvidence(details.stack, state.debugIdMap);
-  const mechanism = known?.exception?.mechanism ?? {
-    type: relationship === "aggregate_member" ? "javascript.aggregate_member" : "javascript.cause",
-    handled: true
-  };
-  const messageEvidence = exceptionMessageEvidence(details.message);
-  const id = state.entries.length;
-  state.entries.push({
-    id,
-    ...(parentId === undefined ? {} : { parentId }),
-    relationship,
-    type: known?.exception?.type ?? errorCauseType(value),
-    ...messageEvidence,
-    mechanism,
-    ...(stackEvidence.frames.length === 0 ? {} : { stackFrames: stackEvidence.frames }),
-    stackFramesState: stackEvidence.frames.length === 0
-      ? "not_captured"
-      : stackEvidence.truncated
-        ? "truncated"
-        : "captured"
-  });
-  return id;
-}
-
-function collectJavaScriptExceptionChildren(value, parentId, state) {
-  if (!isObjectLike(value)) {
-    return;
-  }
-  const cause = safeProperty(value, "cause");
-  if (cause.available && cause.value !== undefined && cause.value !== null) {
-    collectJavaScriptExceptionChild(cause.value, parentId, "cause", state);
-  } else if (!cause.available) {
-    state.truncated = true;
-  }
-  const errors = safeProperty(value, "errors");
-  if (!errors.available) {
-    state.truncated = true;
-  } else if (Array.isArray(errors.value)) {
-    for (const child of errors.value) {
-      collectJavaScriptExceptionChild(child, parentId, "aggregate_member", state);
-    }
-  }
-}
-
-function collectJavaScriptExceptionChild(value, parentId, relationship, state) {
-  if (state.entries.length >= 8) {
-    state.truncated = true;
-    return;
-  }
-  if (isObjectLike(value)) {
-    if (state.seen.has(value)) {
-      state.truncated = true;
-      return;
-    }
-    state.seen.add(value);
-  }
-  const id = appendJavaScriptExceptionNode(value, parentId, relationship, state);
-  if (id !== undefined) {
-    collectJavaScriptExceptionChildren(value, id, state);
-  }
-}
-
-function exceptionMessageEvidence(value) {
-  if (typeof value !== "string") {
-    return { messageState: "not_captured" };
-  }
-  const normalized = value.replace(/\s+/gu, " ").trim();
-  if (normalized === "") {
-    return { messageState: "not_captured" };
-  }
-  return { messageState: "redacted" };
-}
-
-function errorDetails(error) {
-  if (error instanceof Error) {
-    const name = safeProperty(error, "name");
-    const message = safeProperty(error, "message");
-    const stack = safeProperty(error, "stack");
-    return {
-      name: name.available ? stringOrUndefined(name.value) ?? "Error" : "Error",
-      message: message.available ? stringOrUndefined(message.value) : undefined,
-      stack: stack.available && typeof stack.value === "string" && stack.value.trim() !== ""
-        ? stack.value
-        : undefined
-    };
-  }
-  if (error && typeof error === "object") {
-    const name = safeProperty(error, "name");
-    const message = safeProperty(error, "message");
-    const stack = safeProperty(error, "stack");
-    return {
-      name: name.available && typeof name.value === "string" && name.value.trim() !== ""
-        ? name.value
-        : "Error",
-      message: message.available && typeof message.value === "string" && message.value.trim() !== ""
-        ? message.value
-        : undefined,
-      stack: stack.available && typeof stack.value === "string" && stack.value.trim() !== ""
-        ? stack.value
-        : undefined
-    };
-  }
-  if (typeof error === "string" && error.trim() !== "") {
-    return { name: "Error", message: error };
-  }
-  return { name: "Error" };
-}
-
-function safeProperty(value, name) {
-  try {
-    return { available: true, value: value[name] };
-  } catch {
-    return { available: false, value: undefined };
-  }
-}
-
-function boundedIssueExceptionType(value) {
-  const normalized = typeof value === "string" ? value.trim() : "";
-  const characters = Array.from(normalized);
-  if (
-    normalized === ""
-    || characters.length > 256
-    || /[?#]/u.test(normalized)
-    || characters.some((character) => {
-      const code = character.codePointAt(0);
-      return code !== undefined && (code <= 31 || (code >= 127 && code <= 159));
-    })
-  ) {
-    return "Error";
-  }
-  return normalized;
-}
-
-function issueGroupingMetadata(source, details, frame, fingerprint) {
-  const groupingKey = frame
-    ? `${source}:${details.name}:${frame.filename}`
-    : `${source}:${details.name}`;
-  const explicitFingerprint = issueFingerprintOrUndefined(fingerprint);
-  return {
-    issueGroupingKey: groupingKey,
-    issueGroupingSource: explicitFingerprint ? "explicit_fingerprint" : frame ? "error_type_and_frame" : "error_type",
-    ...(explicitFingerprint ? { issueFingerprint: explicitFingerprint } : {})
-  };
-}
-
-function issueFingerprintOrUndefined(value) {
-  if (value === undefined || value === null) {
-    return undefined;
-  }
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new SdkError("validation_error", "issue fingerprint must be a non-empty string");
-  }
-  return value.trim();
-}
-
-function errorCauseMetadata(error) {
-  const state = {
-    items: [],
-    seen: new Set(),
-    sawExceptionGroup: false,
-    truncated: false
-  };
-  if (isObjectLike(error)) {
-    state.seen.add(error);
-    collectNestedErrorCauses(error, state);
-  }
-  if (state.items.length === 0) {
-    return {};
-  }
-  return {
-    errorCauseCount: state.items.length,
-    errorCauseTypes: state.items.map((item) => item.type).join(","),
-    errorCauseSources: state.items.map((item) => item.source).join(","),
-    ...(state.sawExceptionGroup ? { errorExceptionGroup: true } : {}),
-    ...(state.truncated ? { errorCauseTruncated: true } : {})
-  };
-}
-
-function collectNestedErrorCauses(parent, state) {
-  if (!isObjectLike(parent)) {
-    return;
-  }
-  const cause = safeProperty(parent, "cause");
-  if (!cause.available) {
-    state.truncated = true;
-  } else if (cause.value !== undefined && cause.value !== null) {
-    collectErrorCause(cause.value, "cause", state);
-  }
-  const errors = safeProperty(parent, "errors");
-  if (!errors.available) {
-    state.truncated = true;
-  } else if (Array.isArray(errors.value)) {
-    state.sawExceptionGroup = true;
-    for (const [index, child] of errors.value.entries()) {
-      collectErrorCause(child, `errors[${index}]`, state);
-    }
-  }
-}
-
-function collectErrorCause(value, source, state) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (state.items.length >= MAX_ERROR_CAUSES) {
-    state.truncated = true;
-    return;
-  }
-  if (isObjectLike(value)) {
-    if (state.seen.has(value)) {
-      state.truncated = true;
-      return;
-    }
-    state.seen.add(value);
-  }
-  state.items.push({
-    source,
-    type: errorCauseType(value)
-  });
-  collectNestedErrorCauses(value, state);
-}
-
-function errorCauseType(value) {
-  if (isObjectLike(value)) {
-    const constructor = safeProperty(value, "constructor");
-    const constructorNameValue = constructor.available && isObjectLike(constructor.value)
-      ? safeProperty(constructor.value, "name")
-      : { available: false, value: undefined };
-    const constructorName = constructorNameValue.available
-      ? safeCauseTypeName(constructorNameValue.value)
-      : undefined;
-    if (value instanceof Error) {
-      if (constructorName && constructorName !== "Error") {
-        return constructorName;
-      }
-      const name = safeProperty(value, "name");
-      const builtinName = name.available && BUILTIN_ERROR_NAMES.has(name.value)
-        ? name.value
-        : undefined;
-      return builtinName ?? constructorName ?? "Error";
-    }
-    return constructorName ?? "Object";
-  }
-  return "NonError";
-}
-
-function safeCauseTypeName(value) {
-  return typeof value === "string" && /^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/u.test(value) ? value : undefined;
-}
-
-function isObjectLike(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function");
-}
-
-function traceMetadata(trace) {
-  if (trace === undefined || trace === null) {
-    return {};
-  }
-  const normalized = normalizeLogTraceContext(trace);
-  if (!normalized) {
-    return {};
-  }
-  return {
-    traceId: normalized.traceId,
-    spanId: normalized.spanId,
-    ...(normalized.parentSpanId ? { parentSpanId: normalized.parentSpanId } : {}),
-    ...(normalized.sampled !== undefined ? { sampled: normalized.sampled } : {})
-  };
-}
-
-function releaseArtifactMetadata(frame) {
-  if (!frame?.debugId) {
-    return {};
-  }
-  return {
-    releaseArtifactType: "sourcemap",
-    releaseArtifactCodeFile: frame.filename,
-    releaseArtifactDebugId: frame.debugId
-  };
-}
-
-function logbrewLevelFromConsoleMethod(method) {
-  switch (method) {
-    case "debug":
-      return "info";
-    case "warn":
-      return "warning";
-    case "error":
-      return "error";
-    case "info":
-    case "log":
-      return "info";
-    default:
-      throw new SdkError("validation_error", `console method must be one of: ${Array.from(CONSOLE_METHODS).join(", ")}`);
-  }
-}
-
-function createProductActionAttributes(action, options = {}) {
-  const details = productActionDetails(action);
-  const routeTemplate = sanitizeRouteTemplate(details.routeTemplate);
-  return {
-    name: details.name,
-    status: details.status,
-    metadata: compactMetadata({
-      source: "product.action",
-      ...compactMetadata(options.metadata),
-      ...compactMetadata(details.metadata),
-      routeTemplate,
-      sessionId: stringOrUndefined(details.sessionId),
-      traceId: stringOrUndefined(details.traceId),
-      screen: stringOrUndefined(details.screen),
-      funnel: stringOrUndefined(details.funnel),
-      step: stringOrUndefined(details.step),
-      ...productAnalyticsMetadata("interaction", routeTemplate || details.screen)
-    })
-  };
-}
-
-function createNetworkMilestoneAttributes(request, options = {}) {
-  const details = networkMilestoneDetails(request);
-  return {
-    name: details.name,
-    status: details.status,
-    metadata: compactMetadata({
-      source: "network.milestone",
-      ...compactMetadata(options.metadata),
-      ...compactMetadata(details.metadata),
-      routeTemplate: details.routeTemplate,
-      method: details.method,
-      statusCode: details.statusCode,
-      durationMs: details.durationMs,
-      sessionId: stringOrUndefined(details.sessionId),
-      traceId: stringOrUndefined(details.traceId)
-    })
-  };
-}
-
-function parseTraceparent(traceparent) {
-  if (typeof traceparent !== "string" || traceparent.trim() === "") {
-    throw new SdkError("validation_error", "traceparent must be non-empty");
-  }
-
-  const match = TRACEPARENT_PATTERN.exec(traceparent.trim());
-  if (!match) {
-    throw new SdkError("validation_error", "traceparent must use W3C version-traceId-parentSpanId-traceFlags format");
-  }
-
-  const version = match[1].toLowerCase();
-  const traceId = match[2].toLowerCase();
-  const parentSpanId = match[3].toLowerCase();
-  const traceFlags = match[4].toLowerCase();
-  if (version === "ff") {
-    throw new SdkError("validation_error", "traceparent version ff is not allowed");
-  }
-  if (traceId === ZERO_TRACE_ID) {
-    throw new SdkError("validation_error", "traceparent traceId must not be all zeros");
-  }
-  if (parentSpanId === ZERO_SPAN_ID) {
-    throw new SdkError("validation_error", "traceparent parentSpanId must not be all zeros");
-  }
-
-  return {
-    version,
-    traceId,
-    parentSpanId,
-    traceFlags,
-    sampled: (Number.parseInt(traceFlags, 16) & 1) === 1
-  };
-}
-
-function createTraceparent({ traceId, spanId, traceFlags = "01" }) {
-  requireTraceId(traceId);
-  requireSpanId("spanId", spanId);
-  requireTraceFlags(traceFlags);
-  return `00-${traceId.toLowerCase()}-${spanId.toLowerCase()}-${traceFlags.toLowerCase()}`;
-}
-
-function createTraceparentHeaders(input) {
-  return { traceparent: createTraceparent(input) };
-}
-
+  PRODUCT_ANALYTICS_KINDS,
+  PRODUCT_ANALYTICS_SCHEMA_VERSION,
+  createProductActionAttributes
+} = require("./product-action.cjs");
+const { RecordingTransport } = require("./recording-transport.cjs");
+const { SdkError } = require("./sdk-error.cjs");
+const { spanAttributesFromTraceparent } = require("./span-validation.cjs");
+const { createSupportTicketDraft } = require("./support-ticket.cjs");
 const {
   createBaggage,
   createTraceContextHeaders,
+  createTraceparent,
+  createTraceparentHeaders,
   createTracestate,
   parseBaggage,
+  parseTraceparent,
   parseTracestate
-} = buildTraceContextHelpers({
-  SdkError,
-  createTraceparent
-});
-
-const createSupportTicketDraft = buildCreateSupportTicketDraft({
-  SdkError,
-  requireAllowedValue,
-  requireNonEmpty,
-  requireTraceId
-});
-
-const {
-  createLogBrewOpenTelemetrySpanExporter,
-  createLogBrewOpenTelemetrySpanProcessor,
-  logbrewTraceContextFromCurrentOpenTelemetrySpan,
-  logbrewTraceContextFromOpenTelemetrySpan,
-  logbrewTraceContextFromOpenTelemetrySpanContext,
-  spanAttributesFromOpenTelemetryReadableSpan
-} = buildOpenTelemetryHelpers({
-  compactMetadata,
-  isMetadataValue,
-  LogBrewClient,
-  maxSpanEvents: MAX_SPAN_EVENTS,
-  maxSpanLinks: MAX_SPAN_LINKS,
-  requireNonEmpty,
-  requireSpanId,
-  requireTraceId,
-  SdkError,
-  stringOrUndefined
-});
-
-function spanAttributesFromTraceparent(traceparent, attributes) {
-  if (!attributes || Array.isArray(attributes) || typeof attributes !== "object") {
-    throw new SdkError("validation_error", "span attributes must be an object");
-  }
-  const context = parseTraceparent(traceparent);
-  requireNonEmpty("span name", attributes.name);
-  requireSpanId("spanId", attributes.spanId);
-  requireAllowedValue("span status", attributes.status, SPAN_STATUSES);
-  if (attributes.durationMs !== undefined) {
-    if (typeof attributes.durationMs !== "number" || Number.isNaN(attributes.durationMs) || attributes.durationMs < 0) {
-      throw new SdkError("validation_error", "span durationMs must be non-negative");
-    }
-  }
-  const events = validateSpanEvents(attributes.events);
-  const links = validateSpanLinks(attributes.links);
-
-  return {
-    name: attributes.name,
-    traceId: context.traceId,
-    spanId: attributes.spanId.toLowerCase(),
-    parentSpanId: context.parentSpanId,
-    status: attributes.status,
-    ...(attributes.durationMs !== undefined ? { durationMs: attributes.durationMs } : {}),
-    ...(events !== undefined ? { events } : {}),
-    ...(links !== undefined ? { links } : {}),
-    ...(attributes.metadata !== undefined ? { metadata: compactMetadata(attributes.metadata) } : {})
-  };
-}
-
-function createLogBrewPinoDestination(config) {
-  if (!config || typeof config !== "object") {
-    throw new SdkError("validation_error", "Pino destination config must be an object");
-  }
-
-  const client = config.client;
-  if (!(client instanceof LogBrewClient)) {
-    throw new SdkError("validation_error", "Pino destination client must be a LogBrewClient");
-  }
-
-  const transport = config.transport;
-  const flushOnWrite = config.flushOnWrite === true;
-  const includeErrorStack = config.includeErrorStack === true;
-  const logger = config.logger ?? "pino";
-  const metadata = compactMetadata(config.metadata);
-  const timestamp = typeof config.timestamp === "function"
-    ? config.timestamp
-    : () => new Date().toISOString();
-  const eventIdPrefix = config.eventIdPrefix ?? "pino";
-  const onError = typeof config.onError === "function" ? config.onError : () => {};
-  const traceProvider = typeof config.traceProvider === "function" ? config.traceProvider : null;
-  const state = {
-    captured: 0,
-    pendingFlush: Promise.resolve(null)
-  };
-
-  return {
-    write(chunk) {
-      const lines = String(chunk).split(/\r?\n/u).filter((line) => line.trim() !== "");
-      for (const line of lines) {
-        try {
-          const record = JSON.parse(line);
-          state.captured += 1;
-          client.log(
-            `${eventIdPrefix}_${state.captured}`,
-            timestampFromPinoRecord(record, timestamp),
-            logAttributesFromPinoRecord(record, {
-              includeErrorStack,
-              logger,
-              metadata,
-              trace: traceFromProvider(traceProvider, onError)
-            })
-          );
-          if (flushOnWrite && transport) {
-            state.pendingFlush = Promise.resolve(client.flush(transport)).catch((error) => {
-              onError(error);
-              return null;
-            });
-          }
-        } catch (error) {
-          onError(error);
-        }
-      }
-      return true;
-    },
-    async flush() {
-      if (transport && client.pendingEvents() > 0) {
-        state.pendingFlush = Promise.resolve(client.flush(transport)).catch((error) => {
-          onError(error);
-          return null;
-        });
-      }
-      return state.pendingFlush;
-    },
-    end() {
-      return this.flush();
-    }
-  };
-}
-
-function logAttributesFromPinoRecord(record, options = {}) {
-  if (!record || Array.isArray(record) || typeof record !== "object") {
-    throw new SdkError("validation_error", "Pino record must be an object");
-  }
-
-  const level = logbrewLevelFromPinoLevel(record.level);
-  const metadata = {
-    ...compactMetadata(options.metadata),
-    pinoLevel: pinoLevelLabel(record.level),
-    ...pinoContextMetadata(record),
-    ...traceMetadataFromLogContext(options.trace)
-  };
-  if (typeof record.level === "number" && Number.isFinite(record.level)) {
-    metadata.pinoLevelNumber = record.level;
-  }
-  addPinoErrorMetadata(metadata, record.err ?? record.error, options.includeErrorStack === true);
-
-  return {
-    message: pinoMessage(record),
-    level,
-    ...(options.logger ? { logger: options.logger } : {}),
-    metadata
-  };
-}
-
-function timestampFromPinoRecord(record, fallbackTimestamp) {
-  const value = record?.time ?? record?.timestamp;
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return new Date(value).toISOString();
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.valueOf())) {
-      return parsed.toISOString();
-    }
-    return value;
-  }
-  return fallbackTimestamp();
-}
-
-function logbrewLevelFromPinoLevel(level) {
-  if (typeof level === "number" && Number.isFinite(level)) {
-    if (level >= 60) {
-      return "critical";
-    }
-    if (level >= 50) {
-      return "error";
-    }
-    if (level >= 40) {
-      return "warning";
-    }
-    if (level >= 30) {
-      return "info";
-    }
-    return "info";
-  }
-
-  switch (String(level).toLowerCase()) {
-    case "trace":
-    case "debug":
-      return "info";
-    case "warn":
-    case "warning":
-      return "warning";
-    case "error":
-      return "error";
-    case "fatal":
-    case "critical":
-      return "critical";
-    case "info":
-    default:
-      return "info";
-  }
-}
-
-function pinoLevelLabel(level) {
-  if (typeof level === "string" && level.trim() !== "") {
-    return level;
-  }
-  switch (level) {
-    case 10:
-      return "trace";
-    case 20:
-      return "debug";
-    case 30:
-      return "info";
-    case 40:
-      return "warn";
-    case 50:
-      return "error";
-    case 60:
-      return "fatal";
-    default:
-      return typeof level === "number" && Number.isFinite(level) ? String(level) : "info";
-  }
-}
-
-function pinoMessage(record) {
-  if (typeof record.msg === "string" && record.msg.trim() !== "") {
-    return record.msg;
-  }
-  if (typeof record.message === "string" && record.message.trim() !== "") {
-    return record.message;
-  }
-  const error = record.err ?? record.error;
-  if (error && typeof error === "object" && typeof error.message === "string" && error.message.trim() !== "") {
-    return error.message;
-  }
-  return "pino event";
-}
-
-function pinoContextMetadata(record) {
-  const metadata = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (!PINO_RESERVED_FIELDS.has(key) && !isSensitivePinoContextField(key) && isMetadataValue(value)) {
-      metadata[`context.${key}`] = value;
-    }
-  }
-  return metadata;
-}
-
-function isSensitivePinoContextField(key) {
-  const normalized = key.toLowerCase().replace(/[^a-z0-9]+/gu, "");
-  return (
-    PINO_SENSITIVE_CONTEXT_FIELDS.has(normalized)
-    || normalized.endsWith("accesskey")
-    || normalized.endsWith("apikey")
-    || normalized.endsWith("authorization")
-    || normalized.endsWith("body")
-    || normalized.endsWith("cookie")
-    || normalized.endsWith("credentials")
-    || normalized.endsWith("headers")
-    || normalized.endsWith("password")
-    || normalized.endsWith("payload")
-    || normalized.endsWith("privatekey")
-    || normalized.endsWith("query")
-    || normalized.endsWith("secret")
-    || normalized.endsWith("stack")
-    || normalized.endsWith("token")
-    || normalized.endsWith("url")
-  );
-}
-
-function addPinoErrorMetadata(metadata, error, includeErrorStack) {
-  if (!error) {
-    return;
-  }
-  if (error instanceof Error) {
-    metadata.errorName = error.name || "Error";
-    if (error.message) {
-      metadata.errorMessage = error.message;
-    }
-    if (includeErrorStack && error.stack) {
-      metadata.errorStack = error.stack;
-    }
-    return;
-  }
-  if (typeof error === "object") {
-    const name = error.type ?? error.name;
-    const message = error.message;
-    const stack = error.stack;
-    if (typeof name === "string" && name.trim() !== "") {
-      metadata.errorName = name;
-    }
-    if (typeof message === "string" && message.trim() !== "") {
-      metadata.errorMessage = message;
-    }
-    if (includeErrorStack && typeof stack === "string" && stack.trim() !== "") {
-      metadata.errorStack = stack;
-    }
-    return;
-  }
-  if (typeof error === "string" && error.trim() !== "") {
-    metadata.errorMessage = error;
-  }
-}
-
-function requireNonEmpty(label, value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new SdkError("validation_error", `${label} must be non-empty`);
-  }
-}
-
-function requireAllowedValue(label, value, allowedValues) {
-  requireNonEmpty(label, value);
-  if (!allowedValues.has(value)) {
-    throw new SdkError(
-      "validation_error",
-      `${label} must be one of: ${Array.from(allowedValues).join(", ")}`
-    );
-  }
-}
-
-function requireFiniteNumber(label, value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new SdkError("validation_error", `${label} must be a finite number`);
-  }
-}
-
-function requirePositiveInteger(label, value) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new SdkError("validation_error", `${label} must be a positive integer`);
-  }
-}
-
-function requireNonNegativeInteger(label, value) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new SdkError("validation_error", `${label} must be a non-negative integer`);
-  }
-}
-
-function retryAfterMsOrUndefined(value) {
-  if (value === undefined) {
-    return undefined;
-  }
-  return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
-
-function requireTraceId(traceId) {
-  if (typeof traceId !== "string" || !/^[0-9a-fA-F]{32}$/u.test(traceId)) {
-    throw new SdkError("validation_error", "traceId must be 32 lowercase or uppercase hex characters");
-  }
-  if (traceId.toLowerCase() === ZERO_TRACE_ID) {
-    throw new SdkError("validation_error", "traceId must not be all zeros");
-  }
-}
-
-function requireSpanId(label, spanId) {
-  if (typeof spanId !== "string" || !/^[0-9a-fA-F]{16}$/u.test(spanId)) {
-    throw new SdkError("validation_error", `${label} must be 16 lowercase or uppercase hex characters`);
-  }
-  if (spanId.toLowerCase() === ZERO_SPAN_ID) {
-    throw new SdkError("validation_error", `${label} must not be all zeros`);
-  }
-}
-
-function requireTraceFlags(traceFlags) {
-  if (typeof traceFlags !== "string" || !/^[0-9a-fA-F]{2}$/u.test(traceFlags)) {
-    throw new SdkError("validation_error", "traceFlags must be 2 lowercase or uppercase hex characters");
-  }
-}
-
-function requireTimestamp(timestamp) {
-  requireNonEmpty("timestamp", timestamp);
-  const timePortion = timestamp.split("T")[1];
-  if (!timestamp.endsWith("Z")
-    && !(timePortion && (timePortion.includes("+") || /.+-.+/.test(timePortion)))) {
-    throw new SdkError(
-      "validation_error",
-      `timestamp must include a timezone offset: ${timestamp}`
-    );
-  }
-  const match = timestamp.match(RFC3339_TIMESTAMP_PATTERN);
-  const calendar = new Date(0);
-  calendar.setUTCHours(0, 0, 0, 0);
-  calendar.setUTCFullYear(Number(match?.[1]), Number(match?.[2]) - 1, Number(match?.[3]));
-  if (!match
-    || Number(match[1]) === 0
-    || calendar.getUTCFullYear() !== Number(match[1])
-    || calendar.getUTCMonth() !== Number(match[2]) - 1
-    || calendar.getUTCDate() !== Number(match[3])) {
-    throw new SdkError("validation_error", `invalid timestamp: ${timestamp}`);
-  }
-}
-
-function cloneMetadata(metadata) {
-  if (metadata === undefined) {
-    return undefined;
-  }
-  if (!metadata || Array.isArray(metadata) || typeof metadata !== "object") {
-    throw new SdkError("validation_error", "metadata must be an object");
-  }
-  return { ...metadata };
-}
-
-function cloneSpanEvents(events) {
-  return events.map((event) => event.metadata === undefined
-    ? { ...event }
-    : { ...event, metadata: { ...event.metadata } });
-}
-
-function cloneSpanLinks(links) {
-  return links.map((link) => link.metadata === undefined
-    ? { ...link }
-    : { ...link, metadata: { ...link.metadata } });
-}
-
-function cloneEvent(event) {
-  const attributes = { ...event.attributes, ...cloneIssueDiagnostics(event.attributes) };
-  if (Array.isArray(event.attributes.nativeStackFrames)) {
-    attributes.nativeStackFrames = event.attributes.nativeStackFrames.map((frame) => ({ ...frame }));
-  }
-  if (event.attributes.metadata !== undefined) {
-    attributes.metadata = { ...event.attributes.metadata };
-  }
-  if (Array.isArray(event.attributes.events)) {
-    attributes.events = cloneSpanEvents(event.attributes.events);
-  }
-  if (Array.isArray(event.attributes.links)) {
-    attributes.links = cloneSpanLinks(event.attributes.links);
-  }
-  if (event.attributes.context !== undefined) {
-    attributes.context = cloneTelemetryContext(event.attributes.context);
-  }
-  return { ...event, attributes };
-}
-
-function validateRelease(attributes) {
-  requireNonEmpty("release version", attributes.version);
-  if (attributes.commit !== undefined) {
-    requireNonEmpty("release commit", attributes.commit);
-  }
-  return withMetadata({
-    version: attributes.version,
-    ...(attributes.commit ? { commit: attributes.commit } : {}),
-    ...(attributes.notes !== undefined ? { notes: attributes.notes } : {})
-  }, attributes.metadata, attributes.context);
-}
-
-function validateEnvironment(attributes) {
-  requireNonEmpty("environment name", attributes.name);
-  return withMetadata({
-    name: attributes.name,
-    ...(attributes.region !== undefined ? { region: attributes.region } : {})
-  }, attributes.metadata, attributes.context);
-}
-
-function validateIssue(attributes) {
-  requireNonEmpty("issue title", attributes.title);
-  const level = normalizeSeverity("issue level", attributes.level);
-  const stackFrames = validateIssueStackFrames(attributes.stackFrames);
-  const nativeStackFrames = validateNativeStackFrames(attributes.nativeStackFrames);
-  return withMetadata({
-    title: attributes.title,
-    level,
-    ...(attributes.message !== undefined ? { message: attributes.message } : {}),
-    ...(stackFrames !== undefined ? { stackFrames } : {}),
-    ...(nativeStackFrames !== undefined ? { nativeStackFrames } : {}),
-    ...validateIssueDiagnostics(attributes)
-  }, attributes.metadata, attributes.context);
-}
-
-function validateLog(attributes) {
-  requireNonEmpty("log message", attributes.message);
-  const level = normalizeSeverity("log level", attributes.level);
-  return withMetadata({
-    message: attributes.message,
-    level,
-    ...(attributes.logger !== undefined ? { logger: attributes.logger } : {})
-  }, attributes.metadata, attributes.context);
-}
-
-function normalizeSeverity(label, value) {
-  requireAllowedValue(label, value, SEVERITY_VALUES);
-  return SEVERITY_ALIASES.get(value);
-}
-
-function validateSpan(attributes) {
-  requireNonEmpty("span name", attributes.name);
-  requireNonEmpty("span traceId", attributes.traceId);
-  requireNonEmpty("span spanId", attributes.spanId);
-  requireAllowedValue("span status", attributes.status, SPAN_STATUSES);
-  if (attributes.parentSpanId !== undefined) {
-    requireNonEmpty("span parentSpanId", attributes.parentSpanId);
-  }
-  if (attributes.durationMs !== undefined) {
-    if (typeof attributes.durationMs !== "number" || Number.isNaN(attributes.durationMs) || attributes.durationMs < 0) {
-      throw new SdkError("validation_error", "span durationMs must be non-negative");
-    }
-  }
-  const events = validateSpanEvents(attributes.events);
-  const links = validateSpanLinks(attributes.links);
-  return withMetadata({
-    name: attributes.name,
-    traceId: attributes.traceId,
-    spanId: attributes.spanId,
-    status: attributes.status,
-    ...(attributes.parentSpanId !== undefined ? { parentSpanId: attributes.parentSpanId } : {}),
-    ...(attributes.durationMs !== undefined ? { durationMs: attributes.durationMs } : {}),
-    ...(events !== undefined ? { events } : {}),
-    ...(links !== undefined ? { links } : {})
-  }, attributes.metadata, attributes.context);
-}
-
-function validateSpanEvents(events) {
-  if (events === undefined) {
-    return undefined;
-  }
-  if (!Array.isArray(events)) {
-    throw new SdkError("validation_error", "span events must be an array");
-  }
-  if (events.length > MAX_SPAN_EVENTS) {
-    throw new SdkError("validation_error", `span events must contain at most ${MAX_SPAN_EVENTS} entries`);
-  }
-  if (events.length === 0) {
-    return undefined;
-  }
-
-  return events.map((event) => {
-    if (!event || Array.isArray(event) || typeof event !== "object") {
-      throw new SdkError("validation_error", "span event must be an object");
-    }
-    requireNonEmpty("span event name", event.name);
-    if (event.timestamp !== undefined) {
-      requireTimestamp(event.timestamp);
-    }
-    const summary = {
-      name: event.name,
-      ...(event.timestamp !== undefined ? { timestamp: event.timestamp } : {})
-    };
-    if (event.metadata !== undefined) {
-      const metadata = compactMetadata(event.metadata);
-      if (Object.keys(metadata).length > 0) {
-        summary.metadata = metadata;
-      }
-    }
-    return summary;
-  });
-}
-
-function validateSpanLinks(links) {
-  if (links === undefined) {
-    return undefined;
-  }
-  if (!Array.isArray(links)) {
-    throw new SdkError("validation_error", "span links must be an array");
-  }
-  if (links.length > MAX_SPAN_LINKS) {
-    throw new SdkError("validation_error", `span links must contain at most ${MAX_SPAN_LINKS} entries`);
-  }
-  if (links.length === 0) {
-    return undefined;
-  }
-
-  return links.map((link) => {
-    if (!link || Array.isArray(link) || typeof link !== "object") {
-      throw new SdkError("validation_error", "span link must be an object");
-    }
-    requireTraceId(link.traceId);
-    requireSpanId("span link spanId", link.spanId);
-    if (link.sampled !== undefined && typeof link.sampled !== "boolean") {
-      throw new SdkError("validation_error", "span link sampled must be a boolean");
-    }
-    const summary = {
-      traceId: link.traceId.toLowerCase(),
-      spanId: link.spanId.toLowerCase(),
-      ...(link.sampled !== undefined ? { sampled: link.sampled } : {})
-    };
-    if (link.metadata !== undefined) {
-      const metadata = compactMetadata(link.metadata);
-      if (Object.keys(metadata).length > 0) {
-        summary.metadata = metadata;
-      }
-    }
-    return summary;
-  });
-}
-
-function validateAction(attributes) {
-  requireNonEmpty("action name", attributes.name);
-  requireAllowedValue("action status", attributes.status, ACTION_STATUSES);
-  return withMetadata({
-    name: attributes.name,
-    status: attributes.status
-  }, attributes.metadata, attributes.context);
-}
-
-function validateMetric(attributes) {
-  requireNonEmpty("metric name", attributes.name);
-  requireAllowedValue("metric kind", attributes.kind, METRIC_KINDS);
-  requireFiniteNumber("metric value", attributes.value);
-  requireNonEmpty("metric unit", attributes.unit);
-
-  const allowedTemporalities = METRIC_TEMPORALITIES_BY_KIND.get(attributes.kind);
-  requireAllowedValue(`metric temporality for ${attributes.kind}`, attributes.temporality, allowedTemporalities);
-  if (NON_NEGATIVE_METRIC_KINDS.has(attributes.kind) && attributes.value < 0) {
-    throw new SdkError("validation_error", `metric ${attributes.kind} value must be non-negative`);
-  }
-  const description = metricDescriptionOrUndefined(attributes.description);
-
-  return withMetadata({
-    name: attributes.name,
-    ...(description === undefined ? {} : { description }),
-    kind: attributes.kind,
-    value: attributes.value,
-    unit: attributes.unit,
-    temporality: attributes.temporality
-  }, attributes.metadata, attributes.context);
-}
-
-function metricDescriptionOrUndefined(value) {
-  if (value === undefined) {
-    return undefined;
-  }
-  const characters = typeof value === "string" ? Array.from(value) : [];
-  if (
-    typeof value !== "string"
-    || value.trim() === ""
-    || characters.length > MAX_METRIC_DESCRIPTION_LENGTH
-    || characters.some((character) => {
-      const code = character.codePointAt(0);
-      return code !== undefined && (
-        code <= 31
-        || (code >= 127 && code <= 159)
-        || (code >= 0xd800 && code <= 0xdfff)
-        || code === 0x2028
-        || code === 0x2029
-      );
-    })
-  ) {
-    throw new SdkError(
-      "validation_error",
-      `metric description must be a non-blank string of at most ${MAX_METRIC_DESCRIPTION_LENGTH} non-control characters`
-    );
-  }
-  return value.trim();
-}
-
-function productActionDetails(action) {
-  if (typeof action === "string") {
-    return { name: action, status: "success" };
-  }
-  if (!action || Array.isArray(action) || typeof action !== "object") {
-    throw new SdkError("validation_error", "product action must be a string or object");
-  }
-  requireNonEmpty("product action name", action.name);
-  const status = action.status === undefined ? "success" : action.status;
-  requireAllowedValue("product action status", status, ACTION_STATUSES);
-  return {
-    funnel: action.funnel,
-    metadata: action.metadata,
-    name: action.name,
-    routeTemplate: action.routeTemplate,
-    screen: action.screen,
-    sessionId: action.sessionId,
-    status,
-    step: action.step,
-    traceId: action.traceId
-  };
-}
-
-function networkMilestoneDetails(request) {
-  if (typeof request === "string") {
-    return networkMilestoneDetails({ routeTemplate: request });
-  }
-  if (!request || Array.isArray(request) || typeof request !== "object") {
-    throw new SdkError("validation_error", "network milestone must be a string or object");
-  }
-
-  const routeTemplate = sanitizeRouteTemplate(request.routeTemplate);
-  requireNonEmpty("network milestone routeTemplate", routeTemplate);
-  const method = normalizeHttpMethod(request.method);
-  const statusCode = statusCodeOrUndefined(request.statusCode);
-  const status = request.status === undefined
-    ? statusFromStatusCode(statusCode)
-    : request.status;
-  requireAllowedValue("network milestone status", status, ACTION_STATUSES);
-  const durationMs = nonNegativeNumberOrUndefined("network milestone durationMs", request.durationMs);
-  const name = typeof request.name === "string" && request.name.trim() !== ""
-    ? request.name
-    : `network.${method.toLowerCase()} ${routeTemplate}`;
-
-  return {
-    durationMs,
-    metadata: request.metadata,
-    method,
-    name,
-    routeTemplate,
-    sessionId: request.sessionId,
-    status,
-    statusCode,
-    traceId: request.traceId
-  };
-}
-
-function sanitizeRouteTemplate(routeTemplate) {
-  if (routeTemplate === undefined) {
-    return undefined;
-  }
-  if (typeof routeTemplate !== "string") {
-    throw new SdkError("validation_error", "routeTemplate must be a string");
-  }
-  const trimmed = routeTemplate.trim();
-  if (trimmed === "") {
-    return "";
-  }
-  try {
-    const url = new URL(trimmed, "https://logbrew.example");
-    return url.pathname || "/";
-  } catch {
-    return trimmed.split(/[?#]/u)[0] || "/";
-  }
-}
-
-function productAnalyticsMetadata(kind, surface) {
-  const normalizedSurface = boundedProductAnalyticsSurface(surface);
-  return {
-    analyticsSchemaVersion: PRODUCT_ANALYTICS_SCHEMA_VERSION,
-    analyticsKind: kind,
-    analyticsSurface: normalizedSurface
-  };
-}
-
-function boundedProductAnalyticsSurface(surface) {
-  if (typeof surface !== "string") {
-    return undefined;
-  }
-  const normalized = surface.trim();
-  const characters = Array.from(normalized);
-  if (
-    normalized === ""
-    || characters.length > MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH
-    || characters.some((character) => {
-      const code = character.codePointAt(0);
-      return code !== undefined && (code <= 31 || (code >= 127 && code <= 159));
-    })
-  ) {
-    return undefined;
-  }
-  return normalized;
-}
-
-function normalizeHttpMethod(method) {
-  const value = method === undefined ? "GET" : method;
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new SdkError("validation_error", "network milestone method must be a non-empty string");
-  }
-  const normalized = value.trim().toUpperCase();
-  if (!/^[A-Z][A-Z0-9_-]*$/u.test(normalized)) {
-    throw new SdkError("validation_error", "network milestone method must be a valid HTTP method");
-  }
-  return normalized;
-}
-
-function statusCodeOrUndefined(value) {
-  if (value === undefined) {
-    return undefined;
-  }
-  if (!Number.isInteger(value) || value < 100 || value > 599) {
-    throw new SdkError("validation_error", "network milestone statusCode must be an integer from 100 to 599");
-  }
-  return value;
-}
-
-function statusFromStatusCode(statusCode) {
-  if (statusCode !== undefined && statusCode >= 400) {
-    return "failure";
-  }
-  return "success";
-}
-
-function nonNegativeNumberOrUndefined(label, value) {
-  if (value === undefined) {
-    return undefined;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new SdkError("validation_error", `${label} must be a non-negative number`);
-  }
-  return value;
-}
-
-function stringOrUndefined(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : undefined;
-}
-
-function withMetadata(attributes, metadata, context) {
-  const safeMetadata = cloneMetadata(metadata);
-  const safeContext = validateTelemetryContext(context);
-  return {
-    ...attributes,
-    ...(safeMetadata === undefined ? {} : { metadata: safeMetadata }),
-    ...(safeContext === undefined ? {} : { context: safeContext })
-  };
-}
-
-function normalizeConsoleLevels(levels) {
-  const requestedLevels = levels === undefined ? DEFAULT_CONSOLE_LEVELS : levels;
-  if (!Array.isArray(requestedLevels)) {
-    throw new SdkError("validation_error", "console capture levels must be an array");
-  }
-  const normalized = [];
-  for (const method of requestedLevels) {
-    if (!CONSOLE_METHODS.has(method)) {
-      throw new SdkError("validation_error", `console method must be one of: ${Array.from(CONSOLE_METHODS).join(", ")}`);
-    }
-    if (!normalized.includes(method)) {
-      normalized.push(method);
-    }
-  }
-  return normalized;
-}
-
-function consoleMessage(args, includeErrorStack) {
-  const values = Array.isArray(args) ? args : [];
-  const message = values.map((value) => formatConsoleArgument(value, includeErrorStack)).join(" ");
-  return message.trim() === "" ? "console event" : message;
-}
-
-function formatConsoleArgument(value, includeErrorStack) {
-  if (value instanceof Error) {
-    if (includeErrorStack && value.stack) {
-      return value.stack;
-    }
-    return value.message ? `${value.name}: ${value.message}` : value.name;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || value === null || value === undefined) {
-    return String(value);
-  }
-  if (typeof value === "bigint" || typeof value === "symbol") {
-    return String(value);
-  }
-  try {
-    const json = JSON.stringify(value);
-    return json === undefined ? String(value) : json;
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
-}
-
-const { installBrowserBreadcrumbs } = require("./browser-breadcrumbs.cjs");
+} = require("./trace-context.cjs");
+const { TransportError } = require("./transport-error.cjs");
 
 module.exports = {
   PRODUCT_ANALYTICS_KINDS,
   installBrowserBreadcrumbs,
+
   PRODUCT_ANALYTICS_SCHEMA_VERSION,
   createBaggage,
   createIssueAttributesFromError,
   createNetworkMilestoneAttributes,
   createProductActionAttributes,
+
   createLogBrewOpenTelemetrySpanExporter,
   createLogBrewOpenTelemetrySpanProcessor,
   createSupportTicketDraft,
@@ -3006,21 +52,26 @@ module.exports = {
   createTraceparent,
   createTraceparentHeaders,
   createTracestate,
+
   createLogBrewPinoDestination,
   installLogBrewConsoleCapture,
+
   LogBrewClient,
   logbrewTraceContextFromCurrentOpenTelemetrySpan,
   logbrewTraceContextFromOpenTelemetrySpan,
   logbrewTraceContextFromOpenTelemetrySpanContext,
+
   logAttributesFromConsoleArgs,
   logAttributesFromPinoRecord,
   logbrewLevelFromConsoleMethod,
   parseBaggage,
   parseTraceparent,
   parseTracestate,
+
   RecordingTransport,
   SdkError,
   spanAttributesFromOpenTelemetryReadableSpan,
   spanAttributesFromTraceparent,
+
   TransportError
 };