@noego/telemetry 0.0.1

package/dist/browser/index.js

@@ -0,0 +1,1318 @@
+/* @noego/telemetry */
+
+// src/core/helper/canonical_json.ts
+var UTF8_ENCODER = new TextEncoder();
+function compareCanonicalKeys(left, right) {
+  if (left === right) return 0;
+  if (/^[\x00-\x7f]*$/.test(left) && /^[\x00-\x7f]*$/.test(right)) {
+    return left < right ? -1 : 1;
+  }
+  const leftBytes = UTF8_ENCODER.encode(left);
+  const rightBytes = UTF8_ENCODER.encode(right);
+  const length = Math.min(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Canonical telemetry JSON cannot encode a non-finite number");
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => canonicalJson(item));
+    return `[${items.join(",")}]`;
+  }
+  if (typeof value !== "object") {
+    throw new Error(`Canonical telemetry JSON cannot encode ${typeof value}`);
+  }
+  const entries = Object.entries(value).sort(([left], [right]) => compareCanonicalKeys(left, right));
+  const properties = entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`);
+  return `{${properties.join(",")}}`;
+}
+function telemetryUtf8Length(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function telemetryChecksum(value) {
+  const bytes = new TextEncoder().encode(canonicalJson(value));
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+// src/core/bounded_metadata_snapshotter.ts
+var SENTINEL_CIRCULAR = "[telemetry:circular]";
+var SENTINEL_TRUNCATED = "[telemetry:truncated]";
+var BoundedMetadataSnapshotter = class {
+  constructor(limits) {
+    this.limits = limits;
+    this.validateLimits();
+  }
+  limits;
+  snapshot(input) {
+    const state = {
+      bytes: 0,
+      properties: 0,
+      truncatedValues: 0,
+      redactedValues: 0,
+      serializationFailures: 0,
+      seen: /* @__PURE__ */ new WeakSet()
+    };
+    let normalized;
+    try {
+      normalized = this.normalize(input, "$", 0, state);
+    } catch {
+      state.serializationFailures += 1;
+      normalized = { __telemetry: "[telemetry:snapshot-failed]" };
+    }
+    const root = this.ensureObject(normalized);
+    const canonical = canonicalJson(root);
+    const metadata = telemetryUtf8Length(canonical) <= this.limits.maxBytes ? root : Object.freeze({ __telemetry: SENTINEL_TRUNCATED });
+    if (metadata !== root) {
+      state.truncatedValues += 1;
+    }
+    const stats = Object.freeze({
+      estimatedBytes: Math.min(telemetryUtf8Length(canonical), this.limits.maxBytes),
+      truncatedValues: state.truncatedValues,
+      redactedValues: state.redactedValues,
+      serializationFailures: state.serializationFailures
+    });
+    return Object.freeze({ metadata, stats });
+  }
+  normalize(input, path, depth, state) {
+    const replacement = this.redactionFor(path);
+    if (replacement !== null) {
+      state.redactedValues += 1;
+      return replacement;
+    }
+    if (depth > this.limits.maxDepth || state.bytes >= this.limits.maxBytes) {
+      state.truncatedValues += 1;
+      return SENTINEL_TRUNCATED;
+    }
+    if (input === null || typeof input === "boolean") {
+      return input;
+    }
+    if (typeof input === "string") {
+      return this.normalizeString(input, state);
+    }
+    if (typeof input === "number") {
+      return Number.isFinite(input) ? input : `[telemetry:number:${String(input)}]`;
+    }
+    if (typeof input === "bigint") {
+      return `[telemetry:bigint:${input.toString()}]`;
+    }
+    if (typeof input === "undefined") {
+      return "[telemetry:undefined]";
+    }
+    if (typeof input === "symbol") {
+      return `[telemetry:symbol:${input.description ?? ""}]`;
+    }
+    if (typeof input === "function") {
+      return "[telemetry:function]";
+    }
+    if (input instanceof Error) {
+      return this.normalizeError(input, path, depth, state);
+    }
+    if (typeof input !== "object") {
+      return `[telemetry:unsupported:${typeof input}]`;
+    }
+    if (state.seen.has(input)) {
+      return SENTINEL_CIRCULAR;
+    }
+    state.seen.add(input);
+    try {
+      return Array.isArray(input) ? this.normalizeArray(input, path, depth, state) : this.normalizeObject(input, path, depth, state);
+    } finally {
+      state.seen.delete(input);
+    }
+  }
+  normalizeString(input, state) {
+    const stringLimit = Math.min(this.limits.maxStringLength, Math.max(0, this.limits.maxBytes - state.bytes));
+    const truncated = input.length > stringLimit;
+    const normalized = truncated ? input.slice(0, stringLimit) : input;
+    state.bytes += telemetryUtf8Length(normalized);
+    if (truncated) {
+      state.truncatedValues += 1;
+    }
+    return normalized;
+  }
+  normalizeArray(input, path, depth, state) {
+    const length = Math.min(input.length, this.limits.maxArrayLength);
+    const values = [];
+    for (let index = 0; index < length; index += 1) {
+      let item;
+      try {
+        item = input[index];
+      } catch {
+        state.serializationFailures += 1;
+        item = "[telemetry:property-read-failed]";
+      }
+      values.push(this.normalize(item, `${path}[${index}]`, depth + 1, state));
+    }
+    if (input.length > length) {
+      values.push(SENTINEL_TRUNCATED);
+      state.truncatedValues += 1;
+    }
+    return Object.freeze(values);
+  }
+  normalizeObject(input, path, depth, state) {
+    let keys;
+    try {
+      keys = Object.keys(input).sort((left, right) => left.localeCompare(right));
+    } catch {
+      state.serializationFailures += 1;
+      return Object.freeze({ __telemetry: "[telemetry:keys-failed]" });
+    }
+    const output = {};
+    for (const key of keys) {
+      if (state.properties >= this.limits.maxProperties) {
+        output.__telemetry = SENTINEL_TRUNCATED;
+        state.truncatedValues += 1;
+        break;
+      }
+      state.properties += 1;
+      state.bytes += telemetryUtf8Length(key);
+      const childPath = path === "$" ? key : `${path}.${key}`;
+      const redaction = this.redactionFor(childPath);
+      if (redaction !== null) {
+        output[key] = redaction;
+        state.redactedValues += 1;
+        continue;
+      }
+      let property;
+      try {
+        property = Reflect.get(input, key);
+      } catch {
+        state.serializationFailures += 1;
+        property = "[telemetry:property-read-failed]";
+      }
+      output[key] = this.normalize(property, childPath, depth + 1, state);
+    }
+    return Object.freeze(output);
+  }
+  normalizeError(error, path, depth, state) {
+    const name = this.readErrorField(error, "name", state);
+    const message = this.readErrorField(error, "message", state);
+    const stack = this.readErrorField(error, "stack", state).slice(0, this.limits.maxErrorStackLength);
+    return Object.freeze({
+      name: this.normalize(name, `${path}.name`, depth + 1, state),
+      message: this.normalize(message, `${path}.message`, depth + 1, state),
+      stack: this.normalize(stack, `${path}.stack`, depth + 1, state)
+    });
+  }
+  readErrorField(error, field, state) {
+    try {
+      return typeof error[field] === "string" ? error[field] : "";
+    } catch {
+      state.serializationFailures += 1;
+      return "[telemetry:error-field-read-failed]";
+    }
+  }
+  ensureObject(value) {
+    return this.isJsonObject(value) ? value : Object.freeze({ value });
+  }
+  isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  redactionFor(path) {
+    const matchingRule = this.limits.redactions.find((rule) => rule.path === path);
+    return matchingRule?.replacement ?? null;
+  }
+  validateLimits() {
+    const limits = [
+      this.limits.maxBytes,
+      this.limits.maxDepth,
+      this.limits.maxProperties,
+      this.limits.maxArrayLength,
+      this.limits.maxStringLength,
+      this.limits.maxErrorStackLength
+    ];
+    const hasInvalidLimit = limits.some((limit) => !Number.isInteger(limit) || limit <= 0);
+    if (hasInvalidLimit) {
+      throw new Error("Metadata snapshot limits must be positive integers");
+    }
+  }
+};
+
+// src/core/helper/client_defaults.ts
+var DEFAULT_TELEMETRY_ADMISSION_POLICY = Object.freeze({
+  maxQueuedEvents: 2e3,
+  maxQueuedBytes: 2e6,
+  maxBatchEvents: 128,
+  maxBatchBytes: 256e3,
+  maxInFlightBatches: 1,
+  retryLimit: 3,
+  retryBaseDelayMs: 25,
+  sampleRates: Object.freeze({
+    low: 1,
+    normal: 1,
+    high: 1
+  })
+});
+var DEFAULT_METADATA_SNAPSHOT_LIMITS = Object.freeze({
+  maxBytes: 32768,
+  maxDepth: 8,
+  maxProperties: 256,
+  maxArrayLength: 128,
+  maxStringLength: 4096,
+  maxErrorStackLength: 8192,
+  redactions: Object.freeze([])
+});
+var DEFAULT_TELEMETRY_BATCH_VALIDATION_LIMITS = Object.freeze({
+  maxBatchEvents: 1024,
+  maxBatchBytes: 1e6,
+  maxEventBytes: 256e3,
+  maxMetadataBytes: 131072,
+  maxMetadataDepth: 16,
+  maxMetadataProperties: 1024,
+  maxMetadataArrayLength: 1024,
+  maxMetadataStringBytes: 65536,
+  maxDropCounters: 15,
+  maxIdentityBytes: 1024
+});
+
+// src/core/telemetry_batch_contract.ts
+var BATCH_KEYS = Object.freeze([
+  "schemaVersion",
+  "producerId",
+  "sequenceStart",
+  "sequenceEnd",
+  "idempotencyKey",
+  "checksum",
+  "envelopes",
+  "dropCounters"
+]);
+var ENVELOPE_KEYS = Object.freeze([
+  "schemaVersion",
+  "eventId",
+  "producerId",
+  "sequence",
+  "occurredAtMs",
+  "monotonicNs",
+  "source",
+  "processKind",
+  "level",
+  "label",
+  "conversationId",
+  "correlationId",
+  "metadata"
+]);
+var DROP_COUNTER_KEYS = Object.freeze(["reason", "priority", "count"]);
+var DROP_REASONS = /* @__PURE__ */ new Set(["capacity", "sampled", "stopped", "invalid", "transport"]);
+var DROP_PRIORITIES = /* @__PURE__ */ new Set(["low", "normal", "high"]);
+var TelemetryBatchContract = class _TelemetryBatchContract {
+  static schemaVersion = 1;
+  static checksumAlgorithm = "fnv1a64-canonical-json-v1";
+  limits;
+  constructor(limits = {}) {
+    this.limits = Object.freeze({
+      ...DEFAULT_TELEMETRY_BATCH_VALIDATION_LIMITS,
+      ...limits
+    });
+    this.validateLimits();
+  }
+  create(envelopes, dropCounters) {
+    try {
+      return this.createChecked(envelopes, dropCounters);
+    } catch {
+      return { ok: false, error: "Telemetry batch creation failed safe validation" };
+    }
+  }
+  validate(batch) {
+    try {
+      return this.validateChecked(batch);
+    } catch {
+      return { ok: false, error: "Telemetry batch validation failed safely" };
+    }
+  }
+  createChecked(envelopes, dropCounters) {
+    const payloadError = this.validatePayload(envelopes, dropCounters);
+    if (payloadError !== null) {
+      return { ok: false, error: payloadError };
+    }
+    const payloadBytesError = this.payloadBytesError(envelopes, dropCounters);
+    if (payloadBytesError !== null) {
+      return { ok: false, error: payloadBytesError };
+    }
+    const first = envelopes[0];
+    const last = envelopes[envelopes.length - 1];
+    if (!first || !last) {
+      return { ok: false, error: "A telemetry batch must contain a first and last envelope" };
+    }
+    const producerId = first.producerId;
+    const sequenceStart = first.sequence;
+    const sequenceEnd = last.sequence;
+    const checksumPayload = this.checksumPayload(
+      producerId,
+      sequenceStart,
+      sequenceEnd,
+      envelopes,
+      dropCounters
+    );
+    const checksum = telemetryChecksum(checksumPayload);
+    const idempotencyKey = `tb1:${producerId}:${sequenceStart}-${sequenceEnd}:${checksum}`;
+    const batch = Object.freeze({
+      schemaVersion: _TelemetryBatchContract.schemaVersion,
+      producerId,
+      sequenceStart,
+      sequenceEnd,
+      idempotencyKey,
+      checksum,
+      envelopes: Object.freeze([...envelopes]),
+      dropCounters: Object.freeze([...dropCounters])
+    });
+    const framingError = this.validateFraming(batch);
+    if (framingError !== null) {
+      return { ok: false, error: framingError };
+    }
+    const byteError = this.serializedByteError(batch, this.limits.maxBatchBytes, "batch");
+    return byteError === null ? { ok: true, value: this.detachBatch(batch) } : { ok: false, error: byteError };
+  }
+  validateChecked(batch) {
+    if (!this.isRecord(batch)) {
+      return { ok: false, error: "Telemetry batch must be a plain object" };
+    }
+    const schemaVersion = batch.schemaVersion;
+    if (!Number.isSafeInteger(schemaVersion)) {
+      return { ok: false, error: "Telemetry batch schema version must be a safe integer" };
+    }
+    if (schemaVersion !== _TelemetryBatchContract.schemaVersion) {
+      return { ok: false, error: `Unsupported telemetry schema version ${String(schemaVersion)}` };
+    }
+    if (!this.hasExactKeys(batch, BATCH_KEYS)) {
+      return { ok: false, error: "Telemetry batch fields do not match the schema" };
+    }
+    const framingError = this.validateFraming(batch);
+    if (framingError !== null) {
+      return { ok: false, error: framingError };
+    }
+    const recreated = this.create(
+      batch.envelopes,
+      batch.dropCounters
+    );
+    if (!recreated.ok) {
+      return recreated;
+    }
+    const identityError = this.compareFraming(batch, recreated.value);
+    return identityError === null ? { ok: true, value: recreated.value } : { ok: false, error: identityError };
+  }
+  validatePayload(envelopes, dropCounters) {
+    if (!Array.isArray(envelopes) || envelopes.length === 0) {
+      return "A telemetry batch must contain at least one envelope";
+    }
+    if (envelopes.length > this.limits.maxBatchEvents) {
+      return `Telemetry batch exceeds ${this.limits.maxBatchEvents} envelopes`;
+    }
+    const envelopeError = this.validateEnvelopes(envelopes);
+    return envelopeError ?? this.validateDropCounters(dropCounters);
+  }
+  validateEnvelopes(envelopes) {
+    let previousSequence = -1;
+    let producerId = null;
+    for (const envelope of envelopes) {
+      const envelopeError = this.validateEnvelope(envelope, producerId, previousSequence);
+      if (envelopeError !== null) {
+        return envelopeError;
+      }
+      const typedEnvelope = envelope;
+      producerId = typedEnvelope.producerId;
+      previousSequence = typedEnvelope.sequence;
+    }
+    return null;
+  }
+  validateEnvelope(envelope, expectedProducerId, previousSequence) {
+    if (!this.isRecord(envelope) || !this.hasExactKeys(envelope, ENVELOPE_KEYS)) {
+      return "Telemetry envelope fields do not match the schema";
+    }
+    const identityError = this.validateEnvelopeIdentity(envelope, expectedProducerId, previousSequence);
+    if (identityError !== null) {
+      return identityError;
+    }
+    const valueError = this.validateEnvelopeValues(envelope);
+    if (valueError !== null) {
+      return valueError;
+    }
+    const metadataError = this.validateMetadata(envelope.metadata);
+    return metadataError ?? this.serializedByteError(envelope, this.limits.maxEventBytes, "event");
+  }
+  validateEnvelopeIdentity(envelope, expectedProducerId, previousSequence) {
+    if (envelope.schemaVersion !== _TelemetryBatchContract.schemaVersion) {
+      return "Telemetry envelope schema version does not match its batch";
+    }
+    if (!this.isIdentity(envelope.producerId)) {
+      return "Telemetry envelope producer identity is invalid";
+    }
+    if (!this.isSequence(envelope.sequence) || envelope.sequence <= previousSequence) {
+      return "Telemetry envelope sequences must be nonnegative safe integers in increasing order";
+    }
+    if (expectedProducerId !== null && envelope.producerId !== expectedProducerId) {
+      return "A telemetry batch cannot mix producer identities";
+    }
+    const eventId = `${envelope.producerId}:${envelope.sequence}`;
+    if (envelope.eventId !== eventId || telemetryUtf8Length(eventId) > this.limits.maxIdentityBytes) {
+      return "Telemetry envelope event identity is invalid";
+    }
+    return null;
+  }
+  validateEnvelopeValues(envelope) {
+    if (!Number.isSafeInteger(envelope.occurredAtMs) || Number(envelope.occurredAtMs) < 0) {
+      return "Telemetry envelope occurredAtMs must be a nonnegative safe integer";
+    }
+    if (!this.isMonotonicTimestamp(envelope.monotonicNs)) {
+      return "Telemetry envelope monotonicNs is invalid";
+    }
+    if (!this.isIdentity(envelope.source) || !this.isIdentity(envelope.processKind)) {
+      return "Telemetry envelope source and process kind are invalid";
+    }
+    if (!this.isIdentity(envelope.level)) {
+      return "Telemetry envelope level is invalid";
+    }
+    if (!this.isLabel(envelope.label)) {
+      return "Telemetry envelope label is invalid";
+    }
+    if (!this.isConversationId(envelope.conversationId)) {
+      return "Telemetry envelope conversation identity is invalid";
+    }
+    if (!this.isOptionalBoundedString(envelope.correlationId)) {
+      return "Telemetry envelope correlation identity is invalid";
+    }
+    return null;
+  }
+  validateMetadata(metadata) {
+    if (!this.isRecord(metadata)) {
+      return "Telemetry envelope metadata must be a plain JSON object";
+    }
+    const state = { properties: 0, bytes: 0, active: /* @__PURE__ */ new WeakSet() };
+    const jsonError = this.validateJsonValue(metadata, 0, state);
+    return jsonError ?? this.serializedByteError(metadata, this.limits.maxMetadataBytes, "metadata");
+  }
+  validateJsonValue(value, depth, state) {
+    if (value === null || typeof value === "boolean") {
+      state.bytes += value === null ? 4 : 5;
+      return null;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        return "Telemetry metadata contains a non-finite number";
+      }
+      state.bytes += String(value).length;
+      return this.metadataBudgetError(state);
+    }
+    if (typeof value === "string") {
+      if (!this.isWithinUtf8Limit(value, this.limits.maxMetadataStringBytes)) {
+        return "Telemetry metadata string exceeds the receiver limit";
+      }
+      state.bytes += telemetryUtf8Length(value);
+      return this.metadataBudgetError(state);
+    }
+    if (typeof value !== "object") {
+      return "Telemetry metadata contains a non-JSON value";
+    }
+    if (depth > this.limits.maxMetadataDepth) {
+      return "Telemetry metadata exceeds the receiver depth limit";
+    }
+    return Array.isArray(value) ? this.validateJsonArray(value, depth, state) : this.validateJsonObject(value, depth, state);
+  }
+  validateJsonArray(value, depth, state) {
+    if (value.length > this.limits.maxMetadataArrayLength) {
+      return "Telemetry metadata array exceeds the receiver length limit";
+    }
+    const keys = Object.keys(value);
+    if (keys.length !== value.length || Object.getOwnPropertySymbols(value).length > 0) {
+      return "Telemetry metadata arrays must be dense JSON arrays";
+    }
+    return this.validateJsonChildren(value, value, depth, state);
+  }
+  validateJsonObject(value, depth, state) {
+    if (!this.isRecord(value)) {
+      return "Telemetry metadata contains a non-plain object";
+    }
+    const keys = Object.keys(value);
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      return "Telemetry metadata objects cannot contain symbol keys";
+    }
+    state.properties += keys.length;
+    if (state.properties > this.limits.maxMetadataProperties) {
+      return "Telemetry metadata exceeds the receiver property limit";
+    }
+    if (keys.some((key) => !this.isWithinUtf8Limit(key, this.limits.maxMetadataStringBytes))) {
+      return "Telemetry metadata property name exceeds the receiver string limit";
+    }
+    for (const key of keys) {
+      state.bytes += telemetryUtf8Length(key);
+    }
+    const budgetError = this.metadataBudgetError(state);
+    if (budgetError !== null) {
+      return budgetError;
+    }
+    return this.validateJsonChildren(value, keys.map((key) => Reflect.get(value, key)), depth, state);
+  }
+  validateJsonChildren(owner, values, depth, state) {
+    if (state.active.has(owner)) {
+      return "Telemetry metadata cannot contain a cycle";
+    }
+    state.active.add(owner);
+    try {
+      for (const value of values) {
+        const error = this.validateJsonValue(value, depth + 1, state);
+        if (error !== null) {
+          return error;
+        }
+      }
+      return null;
+    } finally {
+      state.active.delete(owner);
+    }
+  }
+  validateDropCounters(dropCounters) {
+    if (!Array.isArray(dropCounters) || dropCounters.length > this.limits.maxDropCounters) {
+      return "Telemetry drop counters exceed the fixed receiver limit";
+    }
+    const identities = /* @__PURE__ */ new Set();
+    let total = 0;
+    for (const counter of dropCounters) {
+      const error = this.validateDropCounter(counter, identities, total);
+      if (error !== null) {
+        return error;
+      }
+      total += counter.count;
+    }
+    return null;
+  }
+  validateDropCounter(counter, identities, currentTotal) {
+    if (!this.isRecord(counter) || !this.hasExactKeys(counter, DROP_COUNTER_KEYS)) {
+      return "Telemetry drop counter fields do not match the schema";
+    }
+    if (!DROP_REASONS.has(String(counter.reason)) || !DROP_PRIORITIES.has(String(counter.priority))) {
+      return "Telemetry drop counter identity is invalid";
+    }
+    if (!Number.isSafeInteger(counter.count) || Number(counter.count) <= 0) {
+      return "Telemetry drop counter count must be a positive safe integer";
+    }
+    if (currentTotal > Number.MAX_SAFE_INTEGER - Number(counter.count)) {
+      return "Telemetry drop counter total exceeds the safe integer range";
+    }
+    const identity = `${counter.reason}:${counter.priority}`;
+    if (identities.has(identity)) {
+      return "Telemetry drop counter identities must be unique within a batch";
+    }
+    identities.add(identity);
+    return null;
+  }
+  validateFraming(batch) {
+    if (!this.isIdentity(batch.producerId)) {
+      return "Telemetry batch producer identity is invalid";
+    }
+    if (!this.isSequence(batch.sequenceStart) || !this.isSequence(batch.sequenceEnd)) {
+      return "Telemetry batch sequence range must use nonnegative safe integers";
+    }
+    if (Number(batch.sequenceEnd) < Number(batch.sequenceStart)) {
+      return "Telemetry batch sequence range is reversed";
+    }
+    if (typeof batch.checksum !== "string" || !/^[a-f0-9]{16}$/.test(batch.checksum)) {
+      return "Telemetry batch checksum is invalid";
+    }
+    if (typeof batch.idempotencyKey !== "string" || !this.isWithinUtf8Limit(batch.idempotencyKey, this.limits.maxIdentityBytes)) {
+      return "Telemetry batch idempotency identity is invalid";
+    }
+    return null;
+  }
+  compareFraming(batch, recreated) {
+    const matches = recreated.checksum === batch.checksum && recreated.idempotencyKey === batch.idempotencyKey && recreated.sequenceStart === batch.sequenceStart && recreated.sequenceEnd === batch.sequenceEnd && recreated.producerId === batch.producerId;
+    return matches ? null : "Telemetry batch framing or checksum is invalid";
+  }
+  checksumPayload(producerId, sequenceStart, sequenceEnd, envelopes, dropCounters) {
+    return {
+      schemaVersion: _TelemetryBatchContract.schemaVersion,
+      producerId,
+      sequenceStart,
+      sequenceEnd,
+      envelopes,
+      dropCounters
+    };
+  }
+  serializedByteError(value, maximum, kind) {
+    const bytes = telemetryUtf8Length(canonicalJson(value));
+    return bytes <= maximum ? null : `Telemetry ${kind} exceeds ${maximum} bytes`;
+  }
+  payloadBytesError(envelopes, dropCounters) {
+    let bytes = 0;
+    for (const envelope of envelopes) {
+      bytes += telemetryUtf8Length(canonicalJson(envelope));
+      if (bytes > this.limits.maxBatchBytes) {
+        return `Telemetry batch exceeds ${this.limits.maxBatchBytes} bytes`;
+      }
+    }
+    bytes += telemetryUtf8Length(canonicalJson(dropCounters));
+    return bytes > this.limits.maxBatchBytes ? `Telemetry batch exceeds ${this.limits.maxBatchBytes} bytes` : null;
+  }
+  metadataBudgetError(state) {
+    return state.bytes > this.limits.maxMetadataBytes ? `Telemetry metadata exceeds ${this.limits.maxMetadataBytes} bytes` : null;
+  }
+  detachBatch(batch) {
+    const detached = JSON.parse(canonicalJson(batch));
+    return this.deepFreeze(detached);
+  }
+  deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+      return value;
+    }
+    for (const child of Object.values(value)) {
+      this.deepFreeze(child);
+    }
+    return Object.freeze(value);
+  }
+  isRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype.constructor?.name === "Object";
+  }
+  hasExactKeys(value, expected) {
+    const keys = Object.keys(value);
+    return Object.getOwnPropertySymbols(value).length === 0 && keys.length === expected.length && expected.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+  }
+  isSequence(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+  }
+  isIdentity(value) {
+    return typeof value === "string" && value.length <= this.limits.maxIdentityBytes && value.trim().length > 0 && this.isWithinUtf8Limit(value, this.limits.maxIdentityBytes) && !/[\u0000-\u001f\u007f]/.test(value);
+  }
+  isLabel(value) {
+    return typeof value === "string" && value.length <= Math.min(256, this.limits.maxIdentityBytes) && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(value) && this.isWithinUtf8Limit(value, Math.min(256, this.limits.maxIdentityBytes));
+  }
+  isMonotonicTimestamp(value) {
+    return value === null || typeof value === "string" && value.length <= this.limits.maxIdentityBytes && /^\d+$/.test(value) && this.isWithinUtf8Limit(value, this.limits.maxIdentityBytes);
+  }
+  isConversationId(value) {
+    return value === null || typeof value === "number" && Number.isSafeInteger(value) || typeof value === "string" && this.isWithinUtf8Limit(value, this.limits.maxIdentityBytes) && !/[\u0000-\u001f\u007f]/.test(value);
+  }
+  isOptionalBoundedString(value) {
+    return value === null || typeof value === "string" && this.isWithinUtf8Limit(value, this.limits.maxIdentityBytes) && !/[\u0000-\u001f\u007f]/.test(value);
+  }
+  isWithinUtf8Limit(value, maximum) {
+    return value.length <= maximum && telemetryUtf8Length(value) <= maximum;
+  }
+  validateLimits() {
+    const values = Object.values(this.limits);
+    if (values.some((value) => !Number.isSafeInteger(value) || value <= 0)) {
+      throw new Error("Telemetry batch validation limits must be positive safe integers");
+    }
+    if (this.limits.maxMetadataBytes > this.limits.maxEventBytes || this.limits.maxEventBytes > this.limits.maxBatchBytes) {
+      throw new Error("Telemetry receiver byte limits must satisfy metadata <= event <= batch");
+    }
+  }
+};
+
+// src/core/telemetry_client.ts
+var TelemetryClient = class {
+  constructor(options) {
+    this.options = options;
+    this.validateOptions();
+    this.snapshotter = new BoundedMetadataSnapshotter(options.metadata);
+  }
+  options;
+  snapshotter;
+  batchContract = new TelemetryBatchContract();
+  queue = [];
+  dropCounts = /* @__PURE__ */ new Map();
+  state = "accepting";
+  nextSequence = 0;
+  queuedBytes = 0;
+  inFlightBatches = 0;
+  drainScheduled = false;
+  activeDrain = null;
+  lastAcknowledgement = null;
+  trace(level, label, metadata = {}) {
+    return this.emit(level, label, metadata);
+  }
+  debug(label, metadata = {}) {
+    return this.emit("debug", label, metadata);
+  }
+  info(label, metadata = {}) {
+    return this.emit("info", label, metadata);
+  }
+  warn(label, metadata = {}) {
+    return this.emit("warn", label, metadata);
+  }
+  error(label, metadata = {}) {
+    return this.emit("error", label, metadata);
+  }
+  fatal(label, metadata = {}) {
+    return this.emit("fatal", label, metadata);
+  }
+  emit(level, label, metadata) {
+    return this.admit({
+      source: this.options.source,
+      processKind: this.options.processKind,
+      level,
+      label,
+      occurredAtMs: this.options.now(),
+      monotonicNs: this.options.monotonicNowNs(),
+      conversationId: null,
+      correlationId: null,
+      metadata
+    });
+  }
+  admit(input) {
+    const sequence = this.nextSequence;
+    this.nextSequence += 1;
+    if (this.state !== "accepting") {
+      this.incrementDrop("stopped", this.priorityFor(input.level));
+      return { kind: "dropped", producerId: this.options.producerId, sequence, reason: "client-stopped" };
+    }
+    const hasInvalidIdentity = !this.isValidLabel(input.label) || !input.source.trim() || !input.processKind.trim() || !Number.isFinite(input.occurredAtMs);
+    if (hasInvalidIdentity) {
+      this.incrementDrop("invalid", this.priorityFor(input.level));
+      return { kind: "dropped", producerId: this.options.producerId, sequence, reason: "invalid-label" };
+    }
+    const priority = this.priorityFor(input.level);
+    if (!this.isSampled(priority)) {
+      this.incrementDrop("sampled", priority);
+      return { kind: "dropped", producerId: this.options.producerId, sequence, reason: "sampled" };
+    }
+    const snapshot = this.snapshotter.snapshot(input.metadata);
+    const extractedCorrelation = this.resolveCorrelation(snapshot.metadata);
+    const correlation = {
+      conversationId: input.conversationId ?? extractedCorrelation.conversationId,
+      correlationId: input.correlationId ?? extractedCorrelation.correlationId
+    };
+    const envelope = this.createEnvelope(sequence, input, snapshot.metadata, correlation);
+    const bytes = telemetryUtf8Length(canonicalJson(envelope));
+    const single = this.batchContract.create([envelope], []);
+    if (!single.ok) {
+      this.incrementDrop("invalid", priority);
+      return { kind: "dropped", producerId: this.options.producerId, sequence, reason: "invalid-envelope" };
+    }
+    const framedBytes = telemetryUtf8Length(canonicalJson(single.value));
+    const queueWouldOverflow = this.queue.length >= this.options.admission.maxQueuedEvents || this.queuedBytes + bytes > this.options.admission.maxQueuedBytes || framedBytes > this.options.admission.maxBatchBytes;
+    if (queueWouldOverflow) {
+      this.incrementDrop("capacity", priority);
+      return { kind: "dropped", producerId: this.options.producerId, sequence, reason: "capacity" };
+    }
+    this.queue.push(Object.freeze({ envelope, bytes }));
+    this.queuedBytes += bytes;
+    this.scheduleDrain();
+    return {
+      kind: "admitted",
+      producerId: this.options.producerId,
+      sequence,
+      eventId: envelope.eventId
+    };
+  }
+  status() {
+    return Object.freeze({
+      state: this.state,
+      producerId: this.options.producerId,
+      nextSequence: this.nextSequence,
+      queuedEvents: this.queue.length,
+      queuedBytes: this.queuedBytes,
+      inFlightBatches: this.inFlightBatches,
+      dropCounters: this.dropCounterSnapshot(),
+      lastAcknowledgement: this.lastAcknowledgement
+    });
+  }
+  async flush(deadlineMs) {
+    this.scheduleDrain();
+    while ((this.queue.length > 0 || this.activeDrain !== null) && this.options.now() < deadlineMs) {
+      const currentDrain = this.activeDrain;
+      if (currentDrain) {
+        await Promise.race([currentDrain, this.options.delay(1)]);
+      } else {
+        await this.options.delay(1);
+      }
+    }
+    await this.settleExternalShutdown(
+      () => this.options.transport.flush(deadlineMs),
+      deadlineMs
+    );
+  }
+  async stop(deadlineMs) {
+    if (this.state === "stopped") {
+      return;
+    }
+    this.state = "draining";
+    await this.flush(deadlineMs);
+    const abandoned = this.queue.splice(0, this.queue.length);
+    if (abandoned.length > 0) {
+      this.incrementDropBy("transport", "normal", abandoned.length);
+      this.queuedBytes = 0;
+    }
+    await this.settleExternalShutdown(
+      () => this.options.transport.close(deadlineMs),
+      deadlineMs
+    );
+    this.state = "stopped";
+  }
+  createEnvelope(sequence, input, metadata, correlation) {
+    return Object.freeze({
+      schemaVersion: TelemetryBatchContract.schemaVersion,
+      eventId: `${this.options.producerId}:${sequence}`,
+      producerId: this.options.producerId,
+      sequence,
+      occurredAtMs: input.occurredAtMs,
+      monotonicNs: input.monotonicNs,
+      source: input.source,
+      processKind: input.processKind,
+      level: input.level.trim().toLowerCase() || "info",
+      label: input.label,
+      conversationId: correlation.conversationId,
+      correlationId: correlation.correlationId,
+      metadata
+    });
+  }
+  resolveCorrelation(metadata) {
+    const conversationValue = metadata.conversationId ?? metadata.threadId ?? null;
+    const conversationId = typeof conversationValue === "string" || typeof conversationValue === "number" ? conversationValue : null;
+    const correlationValue = metadata.correlationId;
+    const correlationId = typeof correlationValue === "string" ? correlationValue : null;
+    return { conversationId, correlationId };
+  }
+  scheduleDrain() {
+    if (this.drainScheduled || this.activeDrain !== null || this.queue.length === 0) {
+      return;
+    }
+    this.drainScheduled = true;
+    try {
+      this.options.schedule(() => {
+        this.drainScheduled = false;
+        const drain = this.drainLoop();
+        this.activeDrain = drain;
+        const settle = () => {
+          this.activeDrain = null;
+          if (this.queue.length > 0) {
+            this.scheduleDrain();
+          }
+        };
+        void drain.then(settle, settle);
+      });
+    } catch {
+      this.drainScheduled = false;
+    }
+  }
+  async drainLoop() {
+    while (this.queue.length > 0) {
+      const dropSnapshot = this.dropCounterSnapshot();
+      const prepared = this.prepareBatch(dropSnapshot);
+      if (prepared === null) {
+        continue;
+      }
+      this.inFlightBatches += 1;
+      try {
+        const acknowledgement = await this.deliverWithRetry(prepared.batch);
+        this.lastAcknowledgement = acknowledgement;
+        if (acknowledgement.kind === "committed") {
+          this.subtractDropSnapshot(prepared.dropCounters);
+        } else {
+          this.incrementDropBy("transport", "normal", prepared.eventCount);
+        }
+      } finally {
+        this.inFlightBatches -= 1;
+      }
+    }
+  }
+  prepareBatch(dropCounters) {
+    const entries = this.peekBatchEntries();
+    const withCounters = this.findFittingBatch(entries, dropCounters);
+    const prepared = withCounters ?? this.findFittingBatch(entries, []);
+    if (prepared === null) {
+      const invalid = this.queue.shift();
+      if (invalid !== void 0) {
+        this.queuedBytes -= invalid.bytes;
+        this.incrementDrop("invalid", this.priorityFor(invalid.envelope.level));
+      }
+      return null;
+    }
+    for (let index = 0; index < prepared.eventCount; index += 1) {
+      const removed = this.queue.shift();
+      if (removed !== void 0) {
+        this.queuedBytes -= removed.bytes;
+      }
+    }
+    return prepared;
+  }
+  peekBatchEntries() {
+    const entries = [];
+    let batchBytes = 0;
+    while (entries.length < this.options.admission.maxBatchEvents) {
+      const next = this.queue[entries.length];
+      if (!next) {
+        break;
+      }
+      const exceedsBatchBytes = entries.length > 0 && batchBytes + next.bytes > this.options.admission.maxBatchBytes;
+      if (exceedsBatchBytes) {
+        break;
+      }
+      batchBytes += next.bytes;
+      entries.push(next);
+    }
+    return entries;
+  }
+  findFittingBatch(entries, dropCounters) {
+    for (let eventCount = entries.length; eventCount > 0; eventCount -= 1) {
+      const created = this.batchContract.create(
+        entries.slice(0, eventCount).map((entry) => entry.envelope),
+        dropCounters
+      );
+      if (created.ok && telemetryUtf8Length(canonicalJson(created.value)) <= this.options.admission.maxBatchBytes) {
+        return Object.freeze({ batch: created.value, dropCounters, eventCount });
+      }
+    }
+    return null;
+  }
+  async deliverWithRetry(batch) {
+    let attempt = 0;
+    while (attempt <= this.options.admission.retryLimit) {
+      let acknowledgement;
+      try {
+        const received = await this.options.transport.send(batch);
+        acknowledgement = this.normalizeAcknowledgement(batch, received, attempt);
+      } catch (cause) {
+        acknowledgement = {
+          kind: "retryable",
+          idempotencyKey: batch.idempotencyKey,
+          reason: this.errorMessage(cause),
+          retryAfterMs: this.retryDelay(attempt),
+          targetStates: []
+        };
+      }
+      if (acknowledgement.kind !== "retryable" || attempt === this.options.admission.retryLimit) {
+        return acknowledgement;
+      }
+      const requestedDelay = Math.max(acknowledgement.retryAfterMs, this.retryDelay(attempt));
+      await this.options.delay(requestedDelay);
+      attempt += 1;
+    }
+    return {
+      kind: "retryable",
+      idempotencyKey: batch.idempotencyKey,
+      reason: "retry-limit-exhausted",
+      retryAfterMs: 0,
+      targetStates: []
+    };
+  }
+  retryDelay(attempt) {
+    return Math.min(
+      Number.MAX_SAFE_INTEGER,
+      this.options.admission.retryBaseDelayMs * 2 ** attempt
+    );
+  }
+  normalizeAcknowledgement(batch, value, attempt) {
+    try {
+      const error = this.acknowledgementError(batch, value);
+      return error === null ? this.detachAcknowledgement(value) : this.invalidAcknowledgement(batch, error, attempt);
+    } catch {
+      return this.invalidAcknowledgement(batch, "acknowledgement could not be inspected", attempt);
+    }
+  }
+  acknowledgementError(batch, value) {
+    if (!this.isRecord(value) || value.idempotencyKey !== batch.idempotencyKey) {
+      return "acknowledgement identity is missing or mismatched";
+    }
+    const targetsError = this.targetStatesError(value.targetStates);
+    if (targetsError !== null) {
+      return targetsError;
+    }
+    switch (value.kind) {
+      case "committed":
+        return this.committedAcknowledgementError(batch, value);
+      case "retryable":
+        return this.retryableAcknowledgementError(value);
+      case "rejected":
+        return this.rejectedAcknowledgementError(value);
+      case "conflict":
+        return this.conflictAcknowledgementError(value);
+      default:
+        return "acknowledgement kind is invalid";
+    }
+  }
+  committedAcknowledgementError(batch, value) {
+    const valid = this.hasExactKeys(value, [
+      "kind",
+      "idempotencyKey",
+      "committedAtMs",
+      "acceptedEvents",
+      "duplicate",
+      "targetStates"
+    ]) && Number.isSafeInteger(value.committedAtMs) && Number(value.committedAtMs) >= 0 && value.acceptedEvents === batch.envelopes.length && typeof value.duplicate === "boolean";
+    return valid ? null : "committed acknowledgement fields are invalid";
+  }
+  retryableAcknowledgementError(value) {
+    const valid = this.hasExactKeys(value, [
+      "kind",
+      "idempotencyKey",
+      "reason",
+      "retryAfterMs",
+      "targetStates"
+    ]) && this.isBoundedReason(value.reason) && Number.isFinite(value.retryAfterMs) && Number(value.retryAfterMs) >= 0 && Number(value.retryAfterMs) <= Number.MAX_SAFE_INTEGER;
+    return valid ? null : "retryable acknowledgement fields are invalid";
+  }
+  rejectedAcknowledgementError(value) {
+    const codes = ["invalid-batch", "unsupported-version", "no-required-terminal", "closed"];
+    const valid = this.hasExactKeys(value, [
+      "kind",
+      "idempotencyKey",
+      "code",
+      "reason",
+      "targetStates"
+    ]) && codes.includes(String(value.code)) && this.isBoundedReason(value.reason);
+    return valid ? null : "rejected acknowledgement fields are invalid";
+  }
+  conflictAcknowledgementError(value) {
+    const valid = this.hasExactKeys(value, ["kind", "idempotencyKey", "reason", "targetStates"]) && this.isBoundedReason(value.reason);
+    return valid ? null : "conflict acknowledgement fields are invalid";
+  }
+  targetStatesError(value) {
+    if (!Array.isArray(value) || value.length > 1024) {
+      return "acknowledgement target states are invalid";
+    }
+    const targetIds = /* @__PURE__ */ new Set();
+    for (const target of value) {
+      if (!this.isValidTargetState(target) || targetIds.has(target.targetId)) {
+        return "acknowledgement target states are invalid";
+      }
+      targetIds.add(target.targetId);
+    }
+    return null;
+  }
+  isValidTargetState(value) {
+    if (!this.isRecord(value) || !this.hasExactKeys(value, ["targetId", "delivery", "state", "attempts", "reason"])) {
+      return false;
+    }
+    const deliveries = ["required", "best-effort"];
+    const states = ["pending", "committed", "failed", "abandoned"];
+    return typeof value.targetId === "string" && value.targetId.length > 0 && telemetryUtf8Length(value.targetId) <= 256 && deliveries.includes(String(value.delivery)) && states.includes(String(value.state)) && Number.isSafeInteger(value.attempts) && Number(value.attempts) >= 0 && (value.reason === null || this.isBoundedReason(value.reason));
+  }
+  invalidAcknowledgement(batch, error, attempt) {
+    return {
+      kind: "retryable",
+      idempotencyKey: batch.idempotencyKey,
+      reason: `Invalid telemetry acknowledgement: ${error}`,
+      retryAfterMs: this.retryDelay(attempt),
+      targetStates: []
+    };
+  }
+  detachAcknowledgement(value) {
+    const detached = JSON.parse(canonicalJson(value));
+    const targetStates = Object.freeze(detached.targetStates.map((target) => Object.freeze({ ...target })));
+    return Object.freeze({ ...detached, targetStates });
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  hasExactKeys(value, expected) {
+    const keys = Object.keys(value);
+    return Object.getOwnPropertySymbols(value).length === 0 && keys.length === expected.length && expected.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+  }
+  isBoundedReason(value) {
+    return typeof value === "string" && telemetryUtf8Length(value) <= 512;
+  }
+  dropCounterSnapshot() {
+    const counters = [...this.dropCounts.entries()].filter(([, count]) => count > 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, count]) => {
+      const [reason, priority] = key.split(":");
+      return Object.freeze({
+        reason,
+        priority,
+        count
+      });
+    });
+    return Object.freeze(counters);
+  }
+  subtractDropSnapshot(snapshot) {
+    for (const counter of snapshot) {
+      const key = `${counter.reason}:${counter.priority}`;
+      const current = this.dropCounts.get(key) ?? 0;
+      this.dropCounts.set(key, Math.max(0, current - counter.count));
+    }
+  }
+  incrementDrop(reason, priority) {
+    this.incrementDropBy(reason, priority, 1);
+  }
+  incrementDropBy(reason, priority, count) {
+    const key = `${reason}:${priority}`;
+    const current = this.dropCounts.get(key) ?? 0;
+    this.dropCounts.set(key, Math.min(Number.MAX_SAFE_INTEGER, current + count));
+  }
+  priorityFor(level) {
+    const normalized = level.trim().toLowerCase();
+    if (normalized === "error" || normalized === "fatal") {
+      return "high";
+    }
+    if (normalized === "trace" || normalized === "debug") {
+      return "low";
+    }
+    return "normal";
+  }
+  isSampled(priority) {
+    const sampleRate = this.options.admission.sampleRates[priority];
+    return sampleRate >= 1 || this.options.random() < sampleRate;
+  }
+  isValidLabel(label) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(label) && label.length <= 256;
+  }
+  errorMessage(cause) {
+    if (cause instanceof Error) {
+      return cause.message.slice(0, 512);
+    }
+    return String(cause).slice(0, 512);
+  }
+  async settleExternalShutdown(work, deadlineMs) {
+    const operation = Promise.resolve().then(work);
+    const remainingMs = deadlineMs - this.options.now();
+    if (!Number.isFinite(remainingMs) || remainingMs <= 0) {
+      void operation.catch(() => void 0);
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (failed, error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        if (failed) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      const timer = setTimeout(
+        () => finish(false),
+        Math.min(remainingMs, 2147483647)
+      );
+      void operation.then(
+        () => finish(false),
+        (error) => finish(true, error)
+      );
+    });
+  }
+  validateOptions() {
+    this.validateIdentityOptions();
+    this.validateOrderedDeliveryOptions();
+    this.validateCapacityOptions();
+    this.validateBatchEventOptions();
+    this.validateBatchByteOptions();
+    this.validateMetadataOptions();
+    this.validateRetryOptions();
+    this.validateSampleRateOptions();
+  }
+  validateIdentityOptions() {
+    if (!this.options.source.trim() || !this.options.processKind.trim() || !this.options.producerId.trim()) {
+      throw new Error("Telemetry client source, process kind, and producer id are required");
+    }
+  }
+  validateOrderedDeliveryOptions() {
+    if (this.options.admission.maxInFlightBatches !== 1) {
+      throw new Error("Ordered telemetry clients currently require maxInFlightBatches to equal 1");
+    }
+  }
+  validateCapacityOptions() {
+    const capacities = [
+      this.options.admission.maxQueuedEvents,
+      this.options.admission.maxQueuedBytes,
+      this.options.admission.maxBatchEvents,
+      this.options.admission.maxBatchBytes,
+      this.options.admission.maxInFlightBatches,
+      this.options.transport.capabilities.maxBatchBytes,
+      this.options.transport.capabilities.boundedCapacity
+    ];
+    if (capacities.some((capacity) => !Number.isSafeInteger(capacity) || capacity <= 0)) {
+      throw new Error("Telemetry client and transport capacities must be positive safe integers");
+    }
+  }
+  validateBatchEventOptions() {
+    if (this.options.admission.maxBatchEvents > this.options.admission.maxQueuedEvents || this.options.admission.maxBatchEvents > this.batchContract.limits.maxBatchEvents) {
+      throw new Error("Telemetry maxBatchEvents must not exceed queue or receiver capacity");
+    }
+  }
+  validateBatchByteOptions() {
+    if (this.options.admission.maxBatchBytes > this.options.admission.maxQueuedBytes || this.options.admission.maxBatchBytes > this.options.transport.capabilities.maxBatchBytes || this.options.admission.maxBatchBytes > this.batchContract.limits.maxBatchBytes) {
+      throw new Error("Telemetry maxBatchBytes must not exceed queue, transport, or receiver capacity");
+    }
+  }
+  validateMetadataOptions() {
+    if (this.options.metadata.maxBytes > this.options.admission.maxBatchBytes) {
+      throw new Error("Telemetry metadata bytes must not exceed maxBatchBytes");
+    }
+  }
+  validateRetryOptions() {
+    if (!Number.isSafeInteger(this.options.admission.retryLimit) || this.options.admission.retryLimit < 0 || !Number.isFinite(this.options.admission.retryBaseDelayMs) || this.options.admission.retryBaseDelayMs < 0) {
+      throw new Error("Telemetry retry limit and delay must be nonnegative finite values");
+    }
+  }
+  validateSampleRateOptions() {
+    const rates = Object.values(this.options.admission.sampleRates);
+    if (rates.some((rate) => !Number.isFinite(rate) || rate < 0 || rate > 1)) {
+      throw new Error("Telemetry sample rates must be between zero and one");
+    }
+  }
+};
+
+// src/platform/browser/browser_telemetry_client.ts
+var BrowserTelemetryClient = class {
+  telemetry;
+  lifecycle = null;
+  pageHideListener = () => {
+    void this.telemetry.flush(Date.now() + 100);
+  };
+  constructor(options) {
+    const producerId = options.producerId ?? this.createProducerId();
+    this.telemetry = new TelemetryClient({
+      source: options.source,
+      processKind: options.processKind,
+      transport: options.transport,
+      admission: options.admission,
+      metadata: options.metadata,
+      producerId,
+      now: () => Date.now(),
+      monotonicNowNs: () => this.monotonicNowNs(),
+      schedule: (work) => queueMicrotask(work),
+      delay: (durationMs) => new Promise((resolve) => setTimeout(resolve, durationMs)),
+      random: () => Math.random()
+    });
+  }
+  attachLifecycle(target) {
+    this.detachLifecycle();
+    this.lifecycle = target;
+    target.addEventListener("pagehide", this.pageHideListener);
+  }
+  detachLifecycle() {
+    this.lifecycle?.removeEventListener("pagehide", this.pageHideListener);
+    this.lifecycle = null;
+  }
+  async stop(deadlineMs) {
+    this.detachLifecycle();
+    await this.telemetry.stop(deadlineMs);
+  }
+  createProducerId() {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi && typeof cryptoApi.randomUUID === "function") {
+      return cryptoApi.randomUUID();
+    }
+    const randomPart = Math.random().toString(36).slice(2);
+    return `browser-${Date.now().toString(36)}-${randomPart}`;
+  }
+  monotonicNowNs() {
+    const performanceApi = globalThis.performance;
+    return performanceApi ? Math.floor(performanceApi.now() * 1e6).toString() : null;
+  }
+};
+export {
+  BrowserTelemetryClient,
+  DEFAULT_METADATA_SNAPSHOT_LIMITS,
+  DEFAULT_TELEMETRY_ADMISSION_POLICY
+};
+//# sourceMappingURL=index.js.map