@q9labsai/chalk-client 4.1.17 → 5.0.1

package/dist/chunk-EWTITNJ3.js

@@ -1,1163 +0,0 @@
-import {
-  TelemetryEventSourceService,
-  createTraceContext,
-  createUuid,
-  journeyHeaders,
-  makeTelemetryEventSourceLayer,
-  traceContextFromJourney
-} from "./chunk-HW5TTZL2.js";
-
-// src/telemetry/client.ts
-import { Effect as Effect2, Layer as Layer2, ManagedRuntime as ManagedRuntime2 } from "effect";
-
-// src/telemetry/attributes.ts
-var MAX_ATTRIBUTE_COUNT = 24;
-var MAX_ATTRIBUTE_KEY_LENGTH = 64;
-var MAX_ATTRIBUTE_VALUE_LENGTH = 256;
-var CORRELATION_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set(["childjourneyid", "rootjourneyid"]);
-var TELEMETRY_BUILT_IN_ATTRIBUTE_KEYS = [
-  "journey_kind",
-  "category",
-  "code",
-  "metric_value",
-  "child_journey_id",
-  "relationship",
-  "method",
-  "route",
-  "duration_ms",
-  "status_code",
-  "direction",
-  "frame_type",
-  "connection_state",
-  "ice_connection_state",
-  "signaling_state",
-  "dtls_state",
-  "selected_candidate_pair_state",
-  "bytes_received",
-  "bytes_sent",
-  "frames_dropped",
-  "inbound_streams",
-  "outbound_streams",
-  "packets_lost",
-  "packets_received",
-  "packets_sent",
-  "transport_entries",
-  "jitter_ms",
-  "round_trip_time_ms"
-];
-var SENSITIVE_IDENTIFIER_ROOTS = [
-  "space",
-  "episode",
-  "participant",
-  ["r", "oom"].join(""),
-  ["sess", "ion"].join(""),
-  ["meet", "ing"].join(""),
-  ["con", "ference"].join(""),
-  "peer",
-  ["att", "endee"].join(""),
-  "user",
-  "agent",
-  "tenant",
-  "member",
-  "external",
-  "connection",
-  "provider",
-  "publication",
-  "stream",
-  "track",
-  "journey",
-  "rootjourney"
-];
-var SENSITIVE_ATTRIBUTE_KEY_PATTERNS = [
-  /(?:access|refresh|id|auth|bearer|csrf|session)?token/u,
-  /(?:authorization|cookie|credential|password|secret|privatekey|apikey)/u,
-  /(?:body|payload|request|response|sdp|candidate|track|media)(?:content|data)?$/u,
-  /(?:displayname|email|phone|username|ipaddress)/u,
-  new RegExp(`(?:${SENSITIVE_IDENTIFIER_ROOTS.join("|")})[a-z0-9]*(?:id|ids|identifier|identifiers|slug|key)$`, "u")
-];
-function normalizeTelemetryAttributes(attributes, options = {}) {
-  if (!isAttributeRecord(attributes)) return void 0;
-  const entries = Object.entries(attributes).filter(validAttributeEntry).filter(([key]) => !isSensitiveAttributeKey(key));
-  const reservedEntries = reservedAttributeEntries(entries, options.reservedKeys ?? []);
-  const reservedKeySet = new Set((options.reservedKeys ?? []).map(normalizeAttributeKey));
-  const ordinaryEntries = entries.filter(([key]) => !reservedKeySet.has(normalizeAttributeKey(key)));
-  const selectedEntries = [...reservedEntries, ...ordinaryEntries].slice(0, MAX_ATTRIBUTE_COUNT);
-  const normalizedEntries = selectedEntries.map(([key, value]) => [key, typeof value === "string" ? value.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH) : value]);
-  return normalizedEntries.length === 0 ? void 0 : Object.fromEntries(normalizedEntries);
-}
-function validAttributeEntry(entry) {
-  const [key, value] = entry;
-  return key.length > 0 && key.length <= MAX_ATTRIBUTE_KEY_LENGTH && isTelemetryAttributeValue(value);
-}
-function reservedAttributeEntries(entries, reservedKeys) {
-  return reservedKeys.flatMap((reservedKey) => {
-    const entry = entries.find(([key]) => key === reservedKey);
-    return entry ? [entry] : [];
-  });
-}
-function isSensitiveAttributeKey(key) {
-  const normalizedKey = normalizeAttributeKey(key);
-  return normalizedKey.length === 0 || !CORRELATION_ATTRIBUTE_KEYS.has(normalizedKey) && SENSITIVE_ATTRIBUTE_KEY_PATTERNS.some((pattern) => pattern.test(normalizedKey));
-}
-function normalizeAttributeKey(key) {
-  return key.toLowerCase().replaceAll(/[^a-z0-9]/gu, "");
-}
-function isTelemetryAttributeValue(value) {
-  return typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string";
-}
-function isAttributeRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/telemetry/delivery.ts
-import { Context, Data, Deferred, Effect, Layer, ManagedRuntime, Queue, Schedule, Semaphore, Stream, SubscriptionRef } from "effect";
-
-// src/telemetry/exporter.ts
-var MAX_KEEPALIVE_BODY_BYTES = 48 * 1024;
-var MAX_JOURNEY_INTAKE_EVENTS_PER_BATCH = 100;
-var MAX_JOURNEY_INTAKE_BODY_BYTES = 1024 * 1024;
-var MAX_JOURNEY_INTAKE_BATCH_BODY_BYTES = MAX_JOURNEY_INTAKE_BODY_BYTES - 64 * 1024;
-var TelemetryExportError = class extends Error {
-  retriable;
-  status;
-  constructor(status) {
-    super(`Journey telemetry export failed with HTTP ${status}`);
-    this.name = "TelemetryExportError";
-    this.status = status;
-    this.retriable = status === 408 || status === 429 || status >= 500;
-  }
-};
-function isRetriableTelemetryExportError(error) {
-  if (error instanceof TelemetryExportError || error instanceof TelemetryPayloadTooLargeError) return error.retriable;
-  return true;
-}
-function createJourneyIntakeExporter(options) {
-  const fetchImplementation = options.fetch || globalThis.fetch;
-  const endpoint = new URL(options.path || "/v1/telemetry/journey-events", options.baseUrl).toString();
-  return (events, exportOptions) => exportJourneyIntake(events, exportOptions, endpoint, fetchImplementation, options);
-}
-async function exportJourneyIntake(events, exportOptions, endpoint, fetchImplementation, options) {
-  const batches = journeyContextBatches(events).flatMap((batch) => eventBatches(batch));
-  if (batches.length === 0) return exportJourneyIntakeBatch(events, exportOptions, endpoint, fetchImplementation, options);
-  const responses = await Promise.all(batches.map((batch) => exportJourneyIntakeBatch(batch, exportOptions, endpoint, fetchImplementation, options)));
-  return responses.reduce((total, response) => ({ accepted_count: total.accepted_count + response.accepted_count, duplicate_count: total.duplicate_count + response.duplicate_count }), { accepted_count: 0, duplicate_count: 0 });
-}
-function eventBatches(events) {
-  const batches = [];
-  let batch = [];
-  for (const event of events) {
-    if (batch.length === 0) {
-      batch = [event];
-      continue;
-    }
-    if (batch.length === MAX_JOURNEY_INTAKE_EVENTS_PER_BATCH || encodedByteLength(journeyIntakeBody([...batch, event])) > MAX_JOURNEY_INTAKE_BATCH_BODY_BYTES) {
-      batches.push(batch);
-      batch = [event];
-      continue;
-    }
-    batch.push(event);
-  }
-  if (batch.length > 0) batches.push(batch);
-  return batches;
-}
-async function exportJourneyIntakeBatch(events, exportOptions, endpoint, fetchImplementation, options) {
-  const body = journeyIntakeBody(events);
-  assertKeepaliveBodySize(body, exportOptions);
-  const headers = await (typeof options.headers === "function" ? options.headers() : options.headers);
-  const response = await fetchImplementation(endpoint, journeyIntakeRequest(events, body, headers, options.credentials, exportOptions));
-  if (!response.ok) throw new TelemetryExportError(response.status);
-  return intakeResponse(await response.json().catch(() => ({})), events.length);
-}
-function assertKeepaliveBodySize(body, options) {
-  if (options?.keepalive && encodedByteLength(body) > MAX_KEEPALIVE_BODY_BYTES) throw new TelemetryPayloadTooLargeError();
-}
-function journeyIntakeRequest(events, body, headers, credentials, options) {
-  return {
-    method: "POST",
-    credentials,
-    headers: { Accept: "application/json", "Content-Type": "application/json", ...headers, ...journeyIntakeHeaders(events) },
-    body,
-    keepalive: options?.keepalive
-  };
-}
-var TelemetryPayloadTooLargeError = class extends Error {
-  retriable = false;
-  constructor() {
-    super(`Journey telemetry keepalive payload exceeds ${MAX_KEEPALIVE_BODY_BYTES} bytes`);
-    this.name = "TelemetryPayloadTooLargeError";
-  }
-};
-function toJourneyIntakeEvent(event) {
-  const { version: _version, ...intakeEvent } = event;
-  return intakeEvent;
-}
-function journeyIntakeHeaders(events) {
-  const firstEvent = events[0];
-  if (!firstEvent) return {};
-  const headers = {
-    "x-chalk-journey-id": firstEvent.journey_id
-  };
-  if (firstEvent.traceparent) headers.traceparent = firstEvent.traceparent;
-  if (firstEvent.tracestate) headers.tracestate = firstEvent.tracestate;
-  return headers;
-}
-function journeyContextBatches(events) {
-  const batches = [];
-  for (const event of events) {
-    const batch = batches.find(([firstEvent]) => firstEvent !== void 0 && sharesJourneyContext(firstEvent, event));
-    if (batch) batch.push(event);
-    else batches.push([event]);
-  }
-  return batches;
-}
-function sharesJourneyContext(left, right) {
-  return left.journey_id === right.journey_id && left.traceparent === right.traceparent && left.tracestate === right.tracestate;
-}
-function intakeResponse(body, eventCount) {
-  const candidate = isRecord(body) ? body : {};
-  return {
-    accepted_count: typeof candidate.accepted_count === "number" ? candidate.accepted_count : eventCount,
-    duplicate_count: typeof candidate.duplicate_count === "number" ? candidate.duplicate_count : 0
-  };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function journeyIntakeBody(events) {
-  return JSON.stringify({
-    events: events.map(({ traceparent: _traceparent, tracestate: _tracestate, ...event }) => event)
-  });
-}
-function encodedByteLength(value) {
-  return new Blob([value]).size;
-}
-
-// src/telemetry/delivery.ts
-var NORMAL_FLUSH_DELAY_MS = 50;
-var TelemetryExportFailure = class extends Data.TaggedError("TelemetryExportFailure") {
-};
-var TelemetryStorageFailure = class extends Data.TaggedError("TelemetryStorageFailure") {
-};
-var TelemetryExporterService = class extends Context.Service()("@chalk/telemetry/TelemetryExporter") {
-};
-var TelemetryStorageService = class extends Context.Service()("@chalk/telemetry/TelemetryStorage") {
-};
-var makeTelemetryExporterLayer = (exporter) => Layer.succeed(TelemetryExporterService, telemetryExporterCapability(exporter));
-var makeFakeTelemetryExporterLayer = (exporter) => makeTelemetryExporterLayer(exporter);
-var makeTelemetryStorageLayer = (storage) => Layer.succeed(TelemetryStorageService, telemetryStorageCapability(storage));
-var makeFakeTelemetryStorageLayer = (storage) => makeTelemetryStorageLayer(storage);
-var TelemetryDeliveryService = class extends Context.Service()("@chalk/telemetry/TelemetryDelivery") {
-};
-var makeTelemetryDeliveryLayer = (options) => Layer.effect(TelemetryDeliveryService, makeTelemetryDeliveryService(options));
-function makeTelemetryDeliveryService(options, exporter = telemetryExporterCapability(options.exporter), storage = telemetryStorageCapability(options.storage)) {
-  return Effect.gen(function* () {
-    const scope = yield* Effect.scope;
-    const delivery = createTelemetryDeliveryService(options, exporter, storage, scope);
-    yield* delivery.startScoped();
-    if (!options.enabled || !storage.configured) yield* delivery.restore();
-    else yield* delivery.restore().pipe(Effect.forkScoped({ startImmediately: true }));
-    yield* Effect.addFinalizer(() => delivery.dispose());
-    return delivery;
-  });
-}
-var DeliveryService = class {
-  constructor(options, exporter, storage, healthRef, pendingRef, queue, scope) {
-    this.options = options;
-    this.exporter = exporter;
-    this.storage = storage;
-    this.healthRef = healthRef;
-    this.pendingRef = pendingRef;
-    this.scope = scope;
-    this.#batchSize = Math.min(options.batchSize, MAX_JOURNEY_INTAKE_EVENTS_PER_BATCH);
-    this.#queue = queue;
-  }
-  options;
-  exporter;
-  storage;
-  healthRef;
-  pendingRef;
-  scope;
-  #activeKeepaliveBatchEventIds = /* @__PURE__ */ new Set();
-  #activeNormalBatchEventIds = /* @__PURE__ */ new Set();
-  #batchSize;
-  #healthListeners = /* @__PURE__ */ new Set();
-  #knownEventIds = /* @__PURE__ */ new Set();
-  #normalGate = Semaphore.makeUnsafe(1);
-  #persistenceGate = Semaphore.makeUnsafe(1);
-  #queue;
-  #ready = Deferred.makeUnsafe();
-  #recentEventIds = [];
-  #timeline = [];
-  #disposed = false;
-  #loaded = false;
-  #restoreStarted = false;
-  #retryScheduled = false;
-  startScoped() {
-    return Stream.fromQueue(this.#queue).pipe(
-      Stream.groupedWithin(this.#batchSize, NORMAL_FLUSH_DELAY_MS),
-      Stream.runForEach(() => this.flush()),
-      Effect.catch(() => Effect.void),
-      Effect.forkScoped,
-      Effect.asVoid
-    );
-  }
-  restore() {
-    return Effect.suspend(() => {
-      if (this.#restoreStarted) return Deferred.await(this.#ready);
-      this.#restoreStarted = true;
-      if (!this.options.enabled || !this.storage.configured) {
-        return Effect.sync(() => {
-          this.#loaded = true;
-        }).pipe(Effect.andThen(Deferred.succeed(this.#ready, void 0)), Effect.asVoid);
-      }
-      return this.storage.load.pipe(
-        Effect.catch((error) => this.storageFailed(error).pipe(Effect.as([]))),
-        Effect.tap(
-          (persisted) => Effect.sync(() => {
-            this.mergeRestored(persisted);
-            this.#loaded = true;
-            Queue.offerAllUnsafe(this.#queue, this.getPendingEventsUnsafe());
-          })
-        ),
-        Effect.andThen(this.persist()),
-        Effect.ensuring(Deferred.succeed(this.#ready, void 0)),
-        Effect.asVoid
-      );
-    });
-  }
-  awaitReady() {
-    return Deferred.await(this.#ready);
-  }
-  dispose() {
-    return Effect.suspend(() => {
-      if (this.#disposed) return Effect.void;
-      this.#disposed = true;
-      this.#retryScheduled = false;
-      return Queue.shutdown(this.#queue);
-    });
-  }
-  persist() {
-    return Effect.suspend(() => {
-      if (!this.#loaded || !this.options.enabled || !this.storage.configured) return Effect.void;
-      return this.#persistenceGate.withPermit(Effect.suspend(() => this.storage.save(this.getPendingEventsUnsafe())).pipe(Effect.catch((error) => this.storageFailed(error))));
-    });
-  }
-  enqueue(event) {
-    return Effect.sync(() => this.enqueueUnsafe(event)).pipe(Effect.andThen(this.persist()));
-  }
-  enqueueUnsafe(event) {
-    if (this.#disposed || !this.options.enabled || this.#knownEventIds.has(event.event_id)) return false;
-    this.trackEventID(event.event_id);
-    const pending = [...this.getPendingEventsUnsafe(), event];
-    this.setPendingUnsafe(pending);
-    this.#timeline.push({ eventId: event.event_id, name: event.name, occurredAt: event.occurred_at, phase: event.phase, state: event.state });
-    if (this.#timeline.length > this.options.maxTimelineEntries) this.#timeline.splice(0, this.#timeline.length - this.options.maxTimelineEntries);
-    this.handleQueueOverflowUnsafe();
-    this.setHealthUnsafe({ queueDepth: this.getPendingEventsUnsafe().length });
-    Queue.offerUnsafe(this.#queue, event);
-    return this.#loaded && this.nextBatch().length === this.#batchSize;
-  }
-  flush(options) {
-    if (options?.keepalive) return this.flushKeepalive();
-    return this.#normalGate.withPermit(this.flushNormal());
-  }
-  getHealthUnsafe() {
-    return { ...SubscriptionRef.getUnsafe(this.healthRef) };
-  }
-  getPendingEventsUnsafe() {
-    return [...SubscriptionRef.getUnsafe(this.pendingRef)];
-  }
-  getTimelineUnsafe() {
-    return [...this.#timeline];
-  }
-  subscribe(listener) {
-    this.#healthListeners.add(listener);
-    listener(this.getHealthUnsafe());
-    return () => this.#healthListeners.delete(listener);
-  }
-  flushNormal() {
-    return Effect.suspend(() => {
-      if (!this.canFlushNormal()) return Effect.void;
-      const batch = this.nextBatch();
-      if (batch.length === 0) return Effect.void;
-      this.activateNormalBatch(batch);
-      return this.deliverNormalBatch(batch).pipe(
-        Effect.flatMap((result) => {
-          if (result === "retry") return Effect.void;
-          const removed = this.removeExportedNormalBatch(batch);
-          this.recordBatchResultUnsafe(result, removed);
-          return this.persist().pipe(Effect.andThen(this.flushNormal()));
-        })
-      );
-    });
-  }
-  deliverNormalBatch(batch) {
-    return this.exporter.export(batch.map(toJourneyIntakeEvent)).pipe(
-      Effect.as("delivered"),
-      Effect.catch((error) => {
-        this.exportFailedUnsafe(error);
-        if (!error.retriable) return Effect.succeed("discarded");
-        return Effect.sync(() => this.deactivateNormalBatch(batch)).pipe(Effect.andThen(this.persist()), Effect.andThen(this.scheduleRetry()), Effect.as("retry"));
-      })
-    );
-  }
-  flushKeepalive() {
-    return Effect.suspend(() => {
-      if (!this.canFlushKeepalive()) return Effect.void;
-      const batch = this.keepaliveBatch();
-      if (batch.length === 0) return Effect.void;
-      this.activateKeepaliveBatch(batch);
-      return this.exporter.export(batch.map(toJourneyIntakeEvent), { keepalive: true }).pipe(
-        Effect.tap(
-          () => Effect.sync(() => {
-            const removed = this.removePendingEvents(batch);
-            if (removed.length > 0) this.recordExportSuccessUnsafe(removed.length);
-          }).pipe(Effect.andThen(this.persist()))
-        ),
-        Effect.catch((error) => Effect.sync(() => this.exportFailedUnsafe(error))),
-        Effect.ensuring(Effect.sync(() => this.deactivateKeepaliveBatch(batch))),
-        Effect.asVoid
-      );
-    });
-  }
-  canFlushNormal() {
-    return !this.#disposed && this.#loaded && this.options.enabled && this.exporter.configured && !this.#retryScheduled && this.getPendingEventsUnsafe().length > 0;
-  }
-  canFlushKeepalive() {
-    return !this.#disposed && this.#loaded && this.options.enabled && this.exporter.configured && this.getPendingEventsUnsafe().length > 0;
-  }
-  nextBatch() {
-    const available = this.getPendingEventsUnsafe().filter((event) => !this.isBatchActive(event));
-    return journeyContextBatches(available)[0]?.slice(0, this.#batchSize) ?? [];
-  }
-  keepaliveBatch() {
-    const available = this.getPendingEventsUnsafe().filter((event) => !this.#activeKeepaliveBatchEventIds.has(event.event_id));
-    const [newestEvent] = available.slice(-this.#batchSize).reverse();
-    if (!newestEvent) return [];
-    return boundedKeepaliveBatch(
-      available.slice(-this.#batchSize).reverse().filter((event) => sharesJourneyContext(event, newestEvent))
-    );
-  }
-  activateNormalBatch(batch) {
-    for (const event of batch) this.#activeNormalBatchEventIds.add(event.event_id);
-  }
-  activateKeepaliveBatch(batch) {
-    for (const event of batch) this.#activeKeepaliveBatchEventIds.add(event.event_id);
-  }
-  removeExportedNormalBatch(batch) {
-    const removed = this.removePendingEvents(batch);
-    this.deactivateNormalBatch(batch);
-    return removed;
-  }
-  deactivateNormalBatch(batch) {
-    for (const event of batch) this.#activeNormalBatchEventIds.delete(event.event_id);
-  }
-  deactivateKeepaliveBatch(batch) {
-    for (const event of batch) this.#activeKeepaliveBatchEventIds.delete(event.event_id);
-  }
-  isBatchActive(event) {
-    return this.#activeNormalBatchEventIds.has(event.event_id) || this.#activeKeepaliveBatchEventIds.has(event.event_id);
-  }
-  removePendingEvents(events) {
-    const eventIds = new Set(events.map((event) => event.event_id));
-    const pending = this.getPendingEventsUnsafe();
-    const removed = pending.filter((event) => eventIds.has(event.event_id));
-    this.setPendingUnsafe(pending.filter((event) => !eventIds.has(event.event_id)));
-    return removed;
-  }
-  trackEventID(eventId) {
-    this.#knownEventIds.add(eventId);
-    this.#recentEventIds.push(eventId);
-    if (this.#recentEventIds.length <= this.options.maxQueueSize * 4) return;
-    const expired = this.#recentEventIds.splice(0, this.#recentEventIds.length - this.options.maxQueueSize * 4);
-    for (const expiredEventId of expired) this.#knownEventIds.delete(expiredEventId);
-  }
-  handleQueueOverflowUnsafe() {
-    const pending = this.getPendingEventsUnsafe();
-    const overflow = Math.max(0, pending.length - this.options.maxQueueSize);
-    const dropped = pending.filter((event) => !this.isBatchActive(event)).slice(0, overflow);
-    if (dropped.length === 0) return;
-    const droppedEventIds = new Set(dropped.map((event) => event.event_id));
-    this.setPendingUnsafe(pending.filter((event) => !droppedEventIds.has(event.event_id)));
-    this.setHealthUnsafe({ droppedEvents: this.getHealthUnsafe().droppedEvents + dropped.length, queueDepth: this.getPendingEventsUnsafe().length });
-    queueMicrotask(() => this.notifyDrops(dropped));
-  }
-  mergeRestored(persisted) {
-    const restored = persisted.map((event) => sanitizeRestoredEvent(event)).filter((event) => !this.#knownEventIds.has(event.event_id));
-    for (const event of restored) this.trackEventID(event.event_id);
-    this.setPendingUnsafe([...restored, ...this.getPendingEventsUnsafe()]);
-    this.handleQueueOverflowUnsafe();
-    this.setHealthUnsafe({ queueDepth: this.getPendingEventsUnsafe().length });
-  }
-  recordBatchResultUnsafe(result, batch) {
-    if (batch.length === 0) return;
-    if (result === "delivered") {
-      this.recordExportSuccessUnsafe(batch.length);
-      return;
-    }
-    this.setHealthUnsafe({ droppedEvents: this.getHealthUnsafe().droppedEvents + batch.length, queueDepth: this.getPendingEventsUnsafe().length });
-    queueMicrotask(() => this.notifyDrops(batch));
-  }
-  recordExportSuccessUnsafe(batchSize) {
-    this.setHealthUnsafe({
-      exportedEvents: this.getHealthUnsafe().exportedEvents + batchSize,
-      lastError: void 0,
-      queueDepth: this.getPendingEventsUnsafe().length,
-      status: "healthy"
-    });
-  }
-  exportFailedUnsafe(error) {
-    this.setHealthUnsafe({
-      failedBatches: this.getHealthUnsafe().failedBatches + 1,
-      lastError: errorMessage(error.cause),
-      queueDepth: this.getPendingEventsUnsafe().length,
-      status: "degraded"
-    });
-  }
-  storageFailed(error) {
-    return Effect.sync(() => this.setHealthUnsafe({ lastError: errorMessage(error.cause), status: "degraded" }));
-  }
-  scheduleRetry() {
-    return Effect.suspend(() => {
-      if (this.#disposed || this.#retryScheduled) return Effect.void;
-      this.#retryScheduled = true;
-      return Effect.forkIn(
-        Effect.void.pipe(
-          Effect.repeat(Schedule.spaced(this.options.retryDelayMs).pipe(Schedule.upTo({ times: 1 }))),
-          Effect.andThen(
-            Effect.sync(() => {
-              this.#retryScheduled = false;
-            })
-          ),
-          Effect.andThen(this.flush()),
-          Effect.catch(() => Effect.void)
-        ),
-        this.scope
-      ).pipe(Effect.asVoid);
-    });
-  }
-  setPendingUnsafe(events) {
-    Effect.runSync(SubscriptionRef.set(this.pendingRef, [...events]));
-  }
-  setHealthUnsafe(update) {
-    const health = { ...this.getHealthUnsafe(), ...update };
-    Effect.runSync(SubscriptionRef.set(this.healthRef, health));
-    for (const listener of this.#healthListeners) {
-      try {
-        listener({ ...health });
-      } catch {
-      }
-    }
-  }
-  notifyDrops(dropped) {
-    try {
-      this.options.onDrop?.(dropped);
-    } catch {
-    }
-  }
-};
-function sanitizeRestoredEvent(event) {
-  const attributes = normalizeTelemetryAttributes(event.attributes, { reservedKeys: TELEMETRY_BUILT_IN_ATTRIBUTE_KEYS });
-  return attributes ? { ...event, attributes } : { ...event, attributes: void 0 };
-}
-function createTelemetryDeliveryService(options, exporter, storage, scope) {
-  return new DeliveryService(
-    options,
-    exporter,
-    storage,
-    Effect.runSync(
-      SubscriptionRef.make({
-        droppedEvents: 0,
-        exportedEvents: 0,
-        failedBatches: 0,
-        queueDepth: 0,
-        status: "idle"
-      })
-    ),
-    Effect.runSync(SubscriptionRef.make([])),
-    Effect.runSync(Queue.make()),
-    scope
-  );
-}
-function telemetryExporterCapability(exporter) {
-  return {
-    configured: exporter !== void 0,
-    export: (events, options) => {
-      if (!exporter) return Effect.void;
-      return Effect.tryPromise({
-        try: () => exporter(events, options),
-        catch: (cause) => new TelemetryExportFailure({ cause, retriable: isRetriableTelemetryExportError(cause) })
-      }).pipe(Effect.asVoid);
-    }
-  };
-}
-function telemetryStorageCapability(storage) {
-  return {
-    configured: storage !== void 0,
-    load: storage ? Effect.tryPromise({ try: () => storage.load(), catch: (cause) => new TelemetryStorageFailure({ cause }) }) : Effect.succeed([]),
-    save: (events) => storage ? Effect.tryPromise({ try: () => storage.save(events), catch: (cause) => new TelemetryStorageFailure({ cause }) }) : Effect.void
-  };
-}
-function boundedKeepaliveBatch(events) {
-  const batch = [];
-  for (const event of events) {
-    if (!keepaliveEventFits(event, batch)) break;
-    batch.unshift(event);
-  }
-  return batch;
-}
-function keepaliveEventFits(event, batch) {
-  return encodedByteLength(journeyIntakeBody([event, ...batch].map(toJourneyIntakeEvent))) <= MAX_KEEPALIVE_BODY_BYTES;
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : "Telemetry exporter failed";
-}
-
-// src/telemetry/rtc.ts
-function summarizeRtcStats(stats) {
-  const accumulator = {
-    bytesReceived: 0,
-    bytesSent: 0,
-    framesDropped: 0,
-    inboundStreams: 0,
-    jitterSamples: [],
-    outboundStreams: 0,
-    packetsLost: 0,
-    packetsReceived: 0,
-    packetsSent: 0,
-    roundTripTimeSamples: [],
-    transportEntries: 0,
-    dtlsStates: [],
-    selectedCandidatePairStates: []
-  };
-  for (const stat of stats) {
-    statHandlers[stat.type ?? ""]?.(accumulator, stat);
-  }
-  return finalizeAccumulator(accumulator);
-}
-function rtcSummaryAttributes(connection, stats) {
-  const summary = summarizeRtcStats(stats);
-  return {
-    bytes_received: summary.bytesReceived,
-    bytes_sent: summary.bytesSent,
-    frames_dropped: summary.framesDropped,
-    inbound_streams: summary.inboundStreams,
-    outbound_streams: summary.outboundStreams,
-    packets_lost: summary.packetsLost,
-    packets_received: summary.packetsReceived,
-    packets_sent: summary.packetsSent,
-    transport_entries: summary.transportEntries,
-    ...summary.dtlsState !== void 0 ? { dtls_state: summary.dtlsState } : {},
-    ...summary.selectedCandidatePairState !== void 0 ? { selected_candidate_pair_state: summary.selectedCandidatePairState } : {},
-    ...connection.connectionState !== void 0 ? { connection_state: connection.connectionState } : {},
-    ...connection.iceConnectionState !== void 0 ? { ice_connection_state: connection.iceConnectionState } : {},
-    ...summary.jitterMs !== void 0 ? { jitter_ms: summary.jitterMs } : {},
-    ...summary.roundTripTimeMs !== void 0 ? { round_trip_time_ms: summary.roundTripTimeMs } : {},
-    ...connection.signalingState !== void 0 ? { signaling_state: connection.signalingState } : {}
-  };
-}
-var statHandlers = {
-  "inbound-rtp": accumulateInbound,
-  "outbound-rtp": accumulateOutbound,
-  "candidate-pair": accumulateTransport,
-  transport: accumulateTransport
-};
-function accumulateInbound(accumulator, stat) {
-  accumulator.inboundStreams += 1;
-  accumulator.bytesReceived += numberOrZero(stat.bytesReceived);
-  accumulator.framesDropped += numberOrZero(stat.framesDropped);
-  accumulator.packetsLost += numberOrZero(stat.packetsLost);
-  accumulator.packetsReceived += numberOrZero(stat.packetsReceived);
-  appendFinite(accumulator.jitterSamples, stat.jitter);
-}
-function accumulateOutbound(accumulator, stat) {
-  accumulator.outboundStreams += 1;
-  accumulator.bytesSent += numberOrZero(stat.bytesSent);
-  accumulator.packetsSent += numberOrZero(stat.packetsSent);
-}
-function accumulateTransport(accumulator, stat) {
-  accumulator.transportEntries += 1;
-  appendFinite(accumulator.roundTripTimeSamples, stat.roundTripTime);
-  appendRtcState(accumulator.dtlsStates, stat.dtlsState, ["new", "connecting", "connected", "closed", "failed"]);
-  if (stat.type === "candidate-pair" && (stat.selected === true || stat.nominated === true)) {
-    appendRtcState(accumulator.selectedCandidatePairStates, stat.state, ["frozen", "waiting", "in-progress", "failed", "succeeded"]);
-  }
-}
-function appendRtcState(states, value, allowed) {
-  if (value !== void 0 && allowed.includes(value) && !states.includes(value)) states.push(value);
-}
-function appendFinite(samples, value) {
-  if (isFiniteNumber(value)) samples.push(value);
-}
-function finalizeAccumulator(accumulator) {
-  const jitterMs = averageMilliseconds(accumulator.jitterSamples);
-  const roundTripTimeMs = averageMilliseconds(accumulator.roundTripTimeSamples);
-  const dtlsState = lastValue(accumulator.dtlsStates);
-  const selectedCandidatePairState = lastValue(accumulator.selectedCandidatePairStates);
-  return {
-    bytesReceived: accumulator.bytesReceived,
-    bytesSent: accumulator.bytesSent,
-    framesDropped: accumulator.framesDropped,
-    inboundStreams: accumulator.inboundStreams,
-    outboundStreams: accumulator.outboundStreams,
-    packetsLost: accumulator.packetsLost,
-    packetsReceived: accumulator.packetsReceived,
-    packetsSent: accumulator.packetsSent,
-    transportEntries: accumulator.transportEntries,
-    ...dtlsState !== void 0 ? { dtlsState } : {},
-    ...selectedCandidatePairState !== void 0 ? { selectedCandidatePairState } : {},
-    ...jitterMs !== void 0 ? { jitterMs } : {},
-    ...roundTripTimeMs !== void 0 ? { roundTripTimeMs } : {}
-  };
-}
-function lastValue(values) {
-  return values.at(-1);
-}
-function averageMilliseconds(samples) {
-  if (samples.length === 0) return void 0;
-  return Math.round(samples.reduce((total, sample) => total + sample, 0) / samples.length * 1e3);
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function numberOrZero(value) {
-  return isFiniteNumber(value) ? value : 0;
-}
-
-// src/telemetry/journey.ts
-var TelemetryJourney = class {
-  context;
-  #telemetry;
-  #lastEventId;
-  #sequence = 0;
-  #terminalEvent;
-  constructor(telemetry, context) {
-    this.#telemetry = telemetry;
-    this.context = context;
-  }
-  get headers() {
-    return journeyHeaders(this.context);
-  }
-  phase(phase, attributes) {
-    if (this.#terminalEvent) return void 0;
-    return this.record({ name: "journey.phase", phase, state: "in_progress", origin_kind: "client", attributes });
-  }
-  terminal(state, attributes) {
-    if (this.#terminalEvent) return this.#terminalEvent;
-    this.#terminalEvent = this.record({ name: "journey.terminal", phase: "terminal", state, origin_kind: "client", attributes });
-    return this.#terminalEvent;
-  }
-  recordHttpRequest(observation) {
-    if (this.#terminalEvent) return void 0;
-    return this.record({
-      name: "http.request",
-      phase: "signaling",
-      state: observation.state || "observed",
-      origin_kind: "http",
-      attributes: httpObservationAttributes(observation)
-    });
-  }
-  recordSyncFrame(observation) {
-    if (this.#terminalEvent) return void 0;
-    return this.record({
-      name: "sync.frame",
-      phase: "signaling",
-      state: observation.state ?? "observed",
-      origin_kind: "sync",
-      upstream_visibility: "propagated",
-      attributes: { direction: observation.direction, frame_type: observation.frameType }
-    });
-  }
-  recordRtcSummary(connection, stats, state = "observed") {
-    if (this.#terminalEvent) return void 0;
-    return this.record({ name: "rtc.summary", phase: "media", state, origin_kind: "rtc", attributes: rtcSummaryAttributes(connection, stats) });
-  }
-  recordDiagnostic(observation) {
-    if (this.#terminalEvent) return void 0;
-    return this.record(
-      {
-        name: "diagnostic.timeline",
-        phase: observation.phase ?? "recovery",
-        state: observation.state ?? "observed",
-        origin_kind: "diagnostic",
-        attributes: {
-          ...observation.attributes,
-          category: observation.category,
-          code: observation.code,
-          ...observation.metricValue !== void 0 ? { metric_value: observation.metricValue } : {}
-        }
-      },
-      { reservedKeys: ["category", "code", ...observation.metricValue === void 0 ? [] : ["metric_value"]] }
-    );
-  }
-  startChild(options) {
-    return this.#telemetry.startJourney({ ...options, parent: this });
-  }
-  record(draft, options) {
-    const event = this.#telemetry.emit(
-      this.context,
-      ++this.#sequence,
-      {
-        ...draft,
-        ...draft.parent_event_id || !this.#lastEventId ? {} : { parent_event_id: this.#lastEventId }
-      },
-      options
-    );
-    this.#lastEventId = event.event_id;
-    return event;
-  }
-  linkChild(child) {
-    return this.record({
-      name: "journey.linked",
-      phase: "root",
-      state: "observed",
-      origin_kind: "client",
-      parent_event_id: this.#lastEventId,
-      attributes: { child_journey_id: child.journeyId, relationship: "fanout" }
-    }).event_id;
-  }
-  start(kind, attributes, parentEventId) {
-    const event = this.#telemetry.emit(this.context, ++this.#sequence, {
-      name: "journey.started",
-      phase: "root",
-      state: "started",
-      origin_kind: "client",
-      ...parentEventId ? { parent_event_id: parentEventId } : {},
-      attributes: { ...attributes, journey_kind: kind }
-    });
-    this.#lastEventId = event.event_id;
-  }
-};
-function httpObservationAttributes(observation) {
-  return {
-    method: observation.method.toUpperCase(),
-    route: observation.route,
-    ...observation.durationMs !== void 0 ? { duration_ms: Math.round(observation.durationMs) } : {},
-    ...observation.statusCode !== void 0 ? { status_code: observation.statusCode } : {}
-  };
-}
-
-// src/telemetry/types.ts
-var TELEMETRY_EVENT_VERSION = 1;
-
-// src/telemetry/client.ts
-var DEFAULT_BATCH_SIZE = 25;
-var DEFAULT_QUEUE_SIZE = 500;
-var DEFAULT_TIMELINE_SIZE = 100;
-var DEFAULT_RETRY_DELAY_MS = 2e3;
-var journeyIdentifierPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var TelemetryClient = class {
-  enabled;
-  #delivery;
-  #eventSource;
-  #ready;
-  #runtime;
-  #disposePromise;
-  constructor(options = {}) {
-    const { enabled = false } = options;
-    this.enabled = enabled;
-    const deliveryOptions = {
-      batchSize: Math.min(positiveInteger(options.maxBatchSize, DEFAULT_BATCH_SIZE), MAX_JOURNEY_INTAKE_EVENTS_PER_BATCH),
-      enabled,
-      exporter: resolveExporter(options),
-      maxQueueSize: positiveInteger(options.maxQueueSize, DEFAULT_QUEUE_SIZE),
-      maxTimelineEntries: positiveInteger(options.maxTimelineEntries, DEFAULT_TIMELINE_SIZE),
-      onDrop: options.onDrop,
-      retryDelayMs: positiveInteger(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS),
-      storage: options.storage
-    };
-    this.#runtime = ManagedRuntime2.make(Layer2.mergeAll(makeTelemetryDeliveryLayer(deliveryOptions), makeTelemetryEventSourceLayer(options.now)));
-    this.#delivery = this.#runtime.runSync(Effect2.service(TelemetryDeliveryService));
-    this.#eventSource = this.#runtime.runSync(Effect2.service(TelemetryEventSourceService));
-    this.#ready = this.#runtime.runPromiseExit(this.#delivery.awaitReady()).then(() => void 0);
-  }
-  startJourney(options) {
-    const journey = new TelemetryJourney(this, createJourneyContext(options, this.#eventSource));
-    journey.start(options.kind, options.attributes, linkParentJourney(options.parent, journey.context));
-    return journey;
-  }
-  getExporterHealth() {
-    return this.#delivery.getHealthUnsafe();
-  }
-  getTimeline() {
-    return this.#delivery.getTimelineUnsafe();
-  }
-  getPendingEvents() {
-    return this.#delivery.getPendingEventsUnsafe();
-  }
-  subscribeExporterHealth(listener) {
-    return this.#delivery.subscribe(listener);
-  }
-  async flush(options) {
-    if (this.#disposePromise) return this.#disposePromise;
-    await this.#ready;
-    if (this.#disposePromise) return this.#disposePromise;
-    await this.#runtime.runPromise(this.#delivery.flush(options));
-  }
-  dispose() {
-    if (this.#disposePromise) return;
-    Effect2.runSync(this.#delivery.dispose());
-    this.#disposePromise = this.#runtime.dispose();
-  }
-  /** Internal for TelemetryJourney. Event construction remains synchronous and never waits for storage or network I/O. */
-  emit(context, sequence, draft, options) {
-    const trace = traceContextFromJourney(context);
-    const { attributes: draftAttributes, ...eventDraft } = draft;
-    const attributes = normalizeTelemetryAttributes(draftAttributes, options);
-    const event = {
-      ...eventDraft,
-      version: TELEMETRY_EVENT_VERSION,
-      event_id: this.#eventSource.createUuid(),
-      journey_id: context.journeyId,
-      sequence,
-      occurred_at: this.#eventSource.now().toISOString(),
-      first_observed_layer: eventDraft.first_observed_layer || eventDraft.origin_kind,
-      upstream_visibility: eventDraft.upstream_visibility || "local",
-      trace_id: trace.traceId,
-      span_id: trace.spanId,
-      traceparent: context.traceparent,
-      ...context.tracestate ? { tracestate: context.tracestate } : {},
-      ...attributes ? { attributes } : {}
-    };
-    const flushNow = this.#delivery.enqueueUnsafe(event);
-    void this.#runtime.runPromiseExit(flushNow ? this.#delivery.flush() : this.#delivery.persist());
-    return event;
-  }
-};
-function createTelemetryClient(options = {}) {
-  return new TelemetryClient(options);
-}
-function resolveExporter(options) {
-  if (options.exporter) return options.exporter;
-  if (!options.baseUrl) return void 0;
-  return createJourneyIntakeExporter({ baseUrl: options.baseUrl, credentials: options.credentials, fetch: options.fetch, path: options.exporterPath });
-}
-function createJourneyContext(options, eventSource) {
-  const parentContext = options.parent?.context;
-  const trace = createTraceContext(parentContext?.traceparent ?? options.traceparent, parentContext?.tracestate ?? options.tracestate);
-  const journeyId = resolveJourneyId(options.journeyId, eventSource);
-  return {
-    journeyId,
-    rootJourneyId: parentContext?.rootJourneyId ?? journeyId,
-    traceparent: trace.traceparent,
-    ...trace.tracestate ? { tracestate: trace.tracestate } : {}
-  };
-}
-function linkParentJourney(parent, child) {
-  if (!parent) return void 0;
-  return parent.linkChild(child);
-}
-function resolveJourneyId(value, eventSource) {
-  if (!value || !validJourneyIdentifier(value)) return eventSource.createUuid();
-  return value.toLowerCase();
-}
-function validJourneyIdentifier(value) {
-  return journeyIdentifierPattern.test(value) && value.replaceAll("0", "").replaceAll("-", "") !== "";
-}
-function positiveInteger(value, fallback) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
-}
-
-// src/telemetry/storage.ts
-function createMemoryTelemetryStorage(initialEvents = []) {
-  let events = [...initialEvents];
-  return {
-    async load() {
-      return [...events];
-    },
-    async save(nextEvents) {
-      events = [...nextEvents];
-    }
-  };
-}
-function createKeyValueTelemetryStorage(storage, key = "chalk.telemetry.v1") {
-  return {
-    async load() {
-      const value = await storage.getItem(key);
-      if (!value) {
-        return [];
-      }
-      return telemetryEvents(JSON.parse(value));
-    },
-    async save(events) {
-      await storage.setItem(key, JSON.stringify(events));
-    }
-  };
-}
-function createBrowserTelemetryStorage(key = "chalk.telemetry.v1") {
-  const storage = getBrowserLocalStorage();
-  if (!storage) return void 0;
-  return createKeyValueTelemetryStorage(
-    {
-      async getItem(storageKey) {
-        return storage.getItem(storageKey);
-      },
-      async setItem(storageKey, value) {
-        storage.setItem(storageKey, value);
-      }
-    },
-    key
-  );
-}
-function createBrowserRuntimeTelemetryStorage(keyPrefix = "chalk.telemetry.v1") {
-  const storage = getBrowserLocalStorage();
-  if (!storage) return void 0;
-  const key = `${keyPrefix}.${createUuid()}`;
-  const state = createRuntimeTelemetryStorageState();
-  return {
-    async load() {
-      return loadRuntimeQueue(storage, keyPrefix, key, state);
-    },
-    async save(events) {
-      saveRuntimeQueue(storage, keyPrefix, key, state, events);
-    }
-  };
-}
-function getBrowserLocalStorage() {
-  try {
-    return globalThis.localStorage;
-  } catch {
-    return void 0;
-  }
-}
-function createRuntimeTelemetryStorageState() {
-  return {
-    adoptedQueues: /* @__PURE__ */ new Map(),
-    knownEventIds: /* @__PURE__ */ new Set(),
-    retainedEvents: /* @__PURE__ */ new Map(),
-    loaded: false
-  };
-}
-function loadRuntimeQueue(storage, keyPrefix, ownKey, state) {
-  const recovered = readAndAdoptQueues(
-    storage,
-    storageKeys(storage).filter((storageKey) => storageKey !== ownKey && isRuntimeTelemetryKey(storageKey, keyPrefix)),
-    state.adoptedQueues
-  );
-  markKnownEvents(state, recovered);
-  state.loaded = true;
-  return recovered;
-}
-function saveRuntimeQueue(storage, keyPrefix, ownKey, state, events) {
-  if (!state.loaded) loadRuntimeQueue(storage, keyPrefix, ownKey, state);
-  const currentEvents = trackCurrentEvents(state, events);
-  retainUnseenAdoptedEvents(state, currentEvents, recoverAdoptedQueues(storage, state.adoptedQueues));
-  persistRuntimeQueue(storage, ownKey, state, currentEvents);
-}
-function trackCurrentEvents(state, events) {
-  const currentEvents = dedupeEvents(events);
-  markKnownEvents(state, currentEvents);
-  for (const event of currentEvents) state.retainedEvents.delete(event.event_id);
-  return currentEvents;
-}
-function markKnownEvents(state, events) {
-  for (const event of events) state.knownEventIds.add(event.event_id);
-}
-function retainUnseenAdoptedEvents(state, currentEvents, recovered) {
-  const currentEventIds = new Set(currentEvents.map((event) => event.event_id));
-  for (const event of recovered) {
-    if (!currentEventIds.has(event.event_id) && !state.knownEventIds.has(event.event_id)) {
-      state.retainedEvents.set(event.event_id, event);
-    }
-  }
-}
-function persistRuntimeQueue(storage, ownKey, state, currentEvents) {
-  const persistedEvents = dedupeEvents([...currentEvents, ...state.retainedEvents.values()]);
-  storage.setItem(ownKey, JSON.stringify(persistedEvents));
-  removeAdoptedQueues(storage, state.adoptedQueues);
-}
-function readAndAdoptQueues(storage, keys, adoptedQueues) {
-  const recovered = [];
-  for (const key of keys) {
-    const value = storage.getItem(key);
-    if (value === null) continue;
-    const events = parseEvents(value);
-    if (!events) {
-      storage.removeItem(key);
-      continue;
-    }
-    adoptedQueues.set(key, value);
-    recovered.push(...events);
-  }
-  return dedupeEvents(recovered);
-}
-function recoverAdoptedQueues(storage, adoptedQueues) {
-  const recovered = [];
-  for (const key of adoptedQueues.keys()) {
-    const value = storage.getItem(key);
-    if (value === null) {
-      adoptedQueues.delete(key);
-      continue;
-    }
-    const events = parseEvents(value);
-    if (!events) {
-      storage.removeItem(key);
-      adoptedQueues.delete(key);
-      continue;
-    }
-    adoptedQueues.set(key, value);
-    recovered.push(...events);
-  }
-  return dedupeEvents(recovered);
-}
-function removeAdoptedQueues(storage, adoptedQueues) {
-  for (const [key, value] of adoptedQueues) {
-    if (storage.getItem(key) !== value) continue;
-    storage.removeItem(key);
-    adoptedQueues.delete(key);
-  }
-}
-function storageKeys(storage) {
-  return Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter((key) => key !== null);
-}
-function isRuntimeTelemetryKey(key, keyPrefix) {
-  return key === keyPrefix || key.startsWith(`${keyPrefix}.`);
-}
-function parseEvents(value) {
-  try {
-    return telemetryEvents(JSON.parse(value));
-  } catch {
-    return void 0;
-  }
-}
-function telemetryEvents(value) {
-  return Array.isArray(value) ? value.filter(isTelemetryEvent) : [];
-}
-function isTelemetryEvent(value) {
-  if (!isRecord2(value)) return false;
-  return typeof value.event_id === "string" && typeof value.first_observed_layer === "string" && typeof value.journey_id === "string" && typeof value.name === "string" && typeof value.occurred_at === "string" && typeof value.origin_kind === "string" && typeof value.phase === "string" && typeof value.sequence === "number" && typeof value.state === "string" && typeof value.upstream_visibility === "string" && value.version === 1;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
-function dedupeEvents(events) {
-  const unique = /* @__PURE__ */ new Map();
-  for (const event of events) unique.set(event.event_id, event);
-  return [...unique.values()];
-}
-
-export {
-  normalizeTelemetryAttributes,
-  createJourneyIntakeExporter,
-  toJourneyIntakeEvent,
-  TelemetryExportFailure,
-  TelemetryStorageFailure,
-  TelemetryExporterService,
-  TelemetryStorageService,
-  makeTelemetryExporterLayer,
-  makeFakeTelemetryExporterLayer,
-  makeTelemetryStorageLayer,
-  makeFakeTelemetryStorageLayer,
-  TelemetryDeliveryService,
-  makeTelemetryDeliveryLayer,
-  summarizeRtcStats,
-  rtcSummaryAttributes,
-  TelemetryJourney,
-  TELEMETRY_EVENT_VERSION,
-  TelemetryClient,
-  createTelemetryClient,
-  createMemoryTelemetryStorage,
-  createKeyValueTelemetryStorage,
-  createBrowserTelemetryStorage,
-  createBrowserRuntimeTelemetryStorage
-};