autotel 3.6.0 → 3.7.0

package/dist/index.d.ts

@@ -1,62 +1,37 @@
-export { A as AutotelConfig, i as init, a as isInitialized, b as isLoggerLocked, l as lockLogger } from './init-DIowiiCh.js';
-import { Span, Context, trace as trace$2 } from '@opentelemetry/api';
-export { AttributeValue, Attributes, Baggage, BaggageEntry, Context, Exception, HrTime, Link, ROOT_CONTEXT, Span, SpanAttributes, SpanContext, SpanKind, Link as SpanLink, SpanStatusCode, TextMapGetter, TextMapSetter, TimeInput, TraceFlags, TraceState, Tracer, TracerProvider, context, trace as otelTrace, propagation } from '@opentelemetry/api';
-import { SpanProcessor, ReadableSpan } from '@opentelemetry/sdk-trace-base';
-export { FilteringSpanProcessor, FilteringSpanProcessorOptions, SpanFilterPredicate } from './filtering-span-processor.js';
-export { NORMALIZER_PATTERNS, NORMALIZER_PRESETS, SpanNameNormalizerConfig, SpanNameNormalizerFn, SpanNameNormalizerPreset, SpanNameNormalizingProcessor, SpanNameNormalizingProcessorOptions } from './span-name-normalizer.js';
-import { AttributeRedactorConfig, AttributeRedactorPreset } from './attribute-redacting-processor.js';
-export { AttributeRedactingProcessor, AttributeRedactingProcessorOptions, AttributeRedactorFn, BuiltinPatternName, MaskFn, REDACTOR_PATTERNS, REDACTOR_PRESETS, ValuePatternConfig, builtinPatterns, createAttributeRedactor, createRedactedSpan, normalizeAttributeRedactorConfig } from './attribute-redacting-processor.js';
-import { trace as trace$1 } from './functional.js';
-export { InstrumentOptions, SpanOptions, WithBaggageOptions, WithNewContextOptions, ctx, instrument, markAsImmediate, span, withBaggage, withNewContext, withTracing } from './functional.js';
-import { EventSubscriber, EventAttributes, AutotelEventContext, EventSchemaMetadata, EventTrackingOptions } from './event-subscriber.js';
-export { FunnelStatus, OutcomeStatus } from './event-subscriber.js';
-export { D as DefineEventOptions, a as DefinedEvent, S as SchemaLike, d as defineEvent } from './define-event-BL6Li7CM.js';
-export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from './correlation-id.js';
-import { T as TraceContext, A as AttributeValue } from './trace-context-DbGKd1Rn.js';
-export { d as defineBaggageSchema } from './trace-context-DbGKd1Rn.js';
-export { ParsedError, parseError } from './parse-error.js';
-export { DrainPipelineOptions, PipelineDrainFn, createDrainPipeline } from './drain-pipeline.js';
-export { AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AdaptiveSampler, AlwaysSampler, NeverSampler, RandomSampler, Sampler, SamplingContext, SamplingPreset, UserIdSampler, createLinkFromHeaders, extractLinksFromBatch, resolveSamplingPreset, samplingPresets } from './sampling.js';
-export { Event, EventsOptions, getEvents, resetEvents } from './event.js';
-export { Metric, MetricsOptions, getMetrics, resetMetrics } from './metric.js';
-export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from './metric-helpers.js';
-import { ViewOptions } from '@opentelemetry/sdk-metrics';
-export { TraceContext as OtelTraceContext, createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from './trace-helpers.js';
-export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from './tracer-provider.js';
-export { DBConfig, HTTPConfig, LLMConfig, MessagingConfig, traceDB, traceHTTP, traceLLM, traceMessaging } from './semantic-helpers.js';
-export { HTTPAttributes, ServiceAttributes, URLAttributes, httpRequestHeaderAttribute, httpResponseHeaderAttribute } from './semantic-conventions.js';
-export { a as AttributeGuardrails, A as AttributePolicy, C as ClientAttrs, b as CloudAttrs, c as CodeAttrs, d as ContainerAttrs, D as DBAttrs, e as DeploymentAttrs, f as DeviceAttrs, E as ErrorAttrs, g as ExceptionAttrs, F as FaaSAttrs, h as FeatureFlagAttrs, G as GenAIAttrs, i as GraphQLAttrs, H as HTTPClientAttrs, j as HTTPServerAttrs, K as K8sAttrs, M as MessagingAttrs, N as NetworkAttrs, O as OTelAttrs, P as PeerAttrs, k as ProcessAttrs, R as RPCAttrs, l as ServerAddressAttrs, m as ServiceAttrs, S as SessionAttrs, T as TLSAttrs, n as ThreadAttrs, o as URLAttrs, U as UserAttrs, p as attrs, q as autoRedactPII, s as dbClient, u as httpClient, v as httpServer, w as identify, x as mergeAttrs, y as mergeServiceResource, z as request, B as safeSetAttributes, I as setDevice, J as setError, L as setException, Q as setSession, V as setUser, W as validateAttribute } from './utils-CLKwaUlG.js';
-export { ConsumerConfig, ConsumerContext, LagMetricsConfig, MessagingOperation, MessagingSystem, ProducerConfig, ProducerContext, traceConsumer, traceProducer } from './messaging.js';
-export { BaggageError, BaggageFieldDefinition, BaggageFieldType, BusinessBaggage, BusinessBaggageValues, SafeBaggageOptions, SafeBaggageSchema, createSafeBaggageSchema } from './business-baggage.js';
-export { StepConfig, StepContext, StepStatus, WorkflowConfig, WorkflowContext, WorkflowStatus, getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './workflow.js';
-import '@opentelemetry/sdk-node';
-import '@opentelemetry/resources';
-import './logger.js';
-import 'pino';
-import '@opentelemetry/sdk-logs';
-import './processors.js';
-import 'node:async_hooks';
-import './event-testing.js';
-import './metric-testing.js';
-
-/** Standalone string redaction for use outside the span processor pipeline. */
-
-type StringRedactor = (value: string) => string;
-declare function createStringRedactor(config: AttributeRedactorConfig | AttributeRedactorPreset): StringRedactor;
-
-/**
- * Span processor that copies baggage entries to span attributes
- *
- * This makes baggage visible in trace UIs without manual attribute setting.
- * Enabled via init({ baggage: true }) or init({ baggage: 'custom-prefix' })
- */
+import { a as AttributeRedactorPreset, c as REDACTOR_PATTERNS, d as builtinPatterns, f as createAttributeRedactor, i as AttributeRedactorFn, l as REDACTOR_PRESETS, m as normalizeAttributeRedactorConfig, n as AttributeRedactingProcessorOptions, o as BuiltinPatternName, p as createRedactedSpan, r as AttributeRedactorConfig, s as MaskFn, t as AttributeRedactingProcessor, u as ValuePatternConfig } from "./attribute-redacting-processor-DtTS9xxh.js";
+import { A as ExceptionAttrs, B as OTelAttrs, C as CloudAttrs, D as DeploymentAttrs, E as DBAttrs, F as HTTPClientAttrs, G as ServiceAttrs, H as ProcessAttrs, I as HTTPServerAttrs, J as ThreadAttrs, K as SessionAttrs, L as K8sAttrs, M as FeatureFlagAttrs, N as GenAIAttrs, O as DeviceAttrs, P as GraphQLAttrs, R as MessagingAttrs, S as ClientAttrs, T as ContainerAttrs, U as RPCAttrs, V as PeerAttrs, W as ServerAddressAttrs, X as UserAttrs, Y as URLAttrs, _ as autoRedactPII, a as httpClient, b as validateAttribute, c as mergeServiceResource, d as setError, f as setException, g as AttributePolicy, h as AttributeGuardrails, i as dbClient, j as FaaSAttrs, k as ErrorAttrs, l as request, m as setUser, n as safeSetAttributes, o as httpServer, p as setSession, q as TLSAttrs, s as identify, t as mergeAttrs, u as setDevice, w as CodeAttrs, x as attrs, z as NetworkAttrs } from "./index-CX0aG1Uh.js";
+import { n as TraceContext$1, r as defineBaggageSchema, t as AttributeValue$2 } from "./trace-context-Cijqoi6e.js";
+import { BaggageError, BaggageFieldDefinition, BaggageFieldType, BusinessBaggage, BusinessBaggageValues, SafeBaggageOptions, SafeBaggageSchema, createSafeBaggageSchema } from "./business-baggage.js";
+import { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from "./correlation-id.js";
+import { _ as samplingPresets, d as SamplingContext, f as SamplingPreset, g as resolveSamplingPreset, h as extractLinksFromBatch, i as AlwaysSampler, l as RandomSampler, m as createLinkFromHeaders, n as AUTOTEL_SAMPLING_TAIL_KEEP, p as UserIdSampler, r as AdaptiveSampler, s as NeverSampler, t as AUTOTEL_SAMPLING_TAIL_EVALUATED, u as Sampler } from "./sampling-CR0Va1VB.js";
+import { InstrumentOptions, SpanOptions, WithBaggageOptions, WithNewContextOptions, ctx, instrument, markAsImmediate, span, trace as trace$2, withBaggage, withNewContext, withTracing } from "./functional.js";
+import { DrainPipelineOptions, PipelineDrainFn, createDrainPipeline } from "./drain-pipeline.js";
+import { a as EventSubscriber, c as OutcomeStatus, i as EventSchemaMetadata, n as EventAttributes, o as EventTrackingOptions, s as FunnelStatus, t as AutotelEventContext } from "./event-subscriber-D1XLkPzi.js";
+import { Event, EventsOptions, getEvents, resetEvents } from "./event.js";
+import { n as FilteringSpanProcessorOptions, r as SpanFilterPredicate, t as FilteringSpanProcessor } from "./filtering-span-processor-B8R8B7Uk.js";
+import { a as lockLogger, i as isLoggerLocked, n as init, o as StringRedactor, r as isInitialized, s as createStringRedactor, t as AutotelConfig } from "./init-DJQOdVlN.js";
+import { a as SpanNameNormalizerPreset, i as SpanNameNormalizerFn, n as NORMALIZER_PRESETS, o as SpanNameNormalizingProcessor, r as SpanNameNormalizerConfig, s as SpanNameNormalizingProcessorOptions, t as NORMALIZER_PATTERNS } from "./span-name-normalizer-8ZOGJuwv.js";
+import { i as defineEvent, n as DefinedEvent, r as SchemaLike, t as DefineEventOptions } from "./define-event-CreknLm3.js";
+import { ParsedError, parseError } from "./parse-error.js";
+import { Metric, MetricsOptions, getMetrics, resetMetrics } from "./metric.js";
+import { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from "./metric-helpers.js";
+import { TraceContext, createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from "./trace-helpers.js";
+import { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from "./tracer-provider.js";
+import { DBConfig, HTTPConfig, LLMConfig, MessagingConfig, traceDB, traceHTTP, traceLLM, traceMessaging } from "./semantic-helpers.js";
+import { a as URLAttributes, i as ServiceAttributes, n as httpResponseHeaderAttribute, r as HTTPAttributes, t as httpRequestHeaderAttribute } from "./semantic-conventions-FhSxv-bK.js";
+import { ConsumerConfig, ConsumerContext, LagMetricsConfig, MessagingOperation, MessagingSystem, ProducerConfig, ProducerContext, traceConsumer, traceProducer } from "./messaging.js";
+import { StepConfig, StepContext, StepStatus, WorkflowConfig, WorkflowContext, WorkflowStatus, getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from "./workflow.js";
+import { ReadableSpan, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { AttributeValue, Attributes, Baggage, BaggageEntry, Context, Context as Context$1, Exception, HrTime, Link, Link as SpanLink, ROOT_CONTEXT, Span, Span as Span$2, SpanAttributes, SpanContext, SpanKind, SpanStatusCode, TextMapGetter, TextMapSetter, TimeInput, TraceFlags, TraceState, Tracer, TracerProvider, context, propagation, trace as otelTrace, trace as trace$1 } from "@opentelemetry/api";
+import { ViewOptions } from "@opentelemetry/sdk-metrics";
 
+//#region src/baggage-span-processor.d.ts
 interface BaggageSpanProcessorOptions {
-    /**
-     * Prefix for baggage attributes
-     * @default 'baggage.'
-     */
-    prefix?: string;
+  /**
+   * Prefix for baggage attributes
+   * @default 'baggage.'
+   */
+  prefix?: string;
 }
 /**
  * Span processor that automatically copies baggage entries to span attributes
@@ -90,28 +65,18 @@ interface BaggageSpanProcessorOptions {
  * ```
  */
 declare class BaggageSpanProcessor implements SpanProcessor {
-    private readonly prefix;
-    constructor(options?: BaggageSpanProcessorOptions);
-    onStart(span: Span, parentContext: Context): void;
-    onEnd(_span: ReadableSpan): void;
-    shutdown(): Promise<void>;
-    forceFlush(): Promise<void>;
-}
-
-/**
- * Hybrid `trace` export: callable like autotel's `trace(fn)`, AND exposes the
- * full `@opentelemetry/api` `TraceAPI` surface (`trace.getActiveSpan()`,
- * `trace.getTracer()`, …) so existing OTel code "just works" when imported
- * from `autotel`.
- *
- * Implementation: `Object.assign` mutates the autotel `trace` function to
- * attach the OTel TraceAPI methods. Because every reference to `trace` across
- * autotel resolves to the same function instance, this is a one-time, global
- * augmentation.
- */
-
-declare const trace: typeof trace$1 & typeof trace$2;
-
+  private readonly prefix;
+  constructor(options?: BaggageSpanProcessorOptions);
+  onStart(span: Span$2, parentContext: Context$1): void;
+  onEnd(_span: ReadableSpan): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+//#endregion
+//#region src/trace-hybrid.d.ts
+declare const trace: typeof trace$2 & typeof trace$1;
+//#endregion
+//#region src/operation-context.d.ts
 /**
  * Operation context tracking using AsyncLocalStorage
  *
@@ -125,11 +90,11 @@ declare const trace: typeof trace$1 & typeof trace$2;
  * Operation context that flows through async operations
  */
 interface OperationContext {
-    /**
-     * The name of the current operation
-     * This is set by trace() or span() and can be read by events
-     */
-    name: string;
+  /**
+   * The name of the current operation
+   * This is set by trace() or span() and can be read by events
+   */
+  name: string;
 }
 /**
  * Get the current operation context (if any)
@@ -166,7 +131,8 @@ declare function getOperationContext(): OperationContext | undefined;
  * ```
  */
 declare function runInOperationContext<T>(name: string, fn: () => T): T;
-
+//#endregion
+//#region src/rate-limiter.d.ts
 /**
  * Token bucket rate limiter for event subscribers
  *
@@ -174,44 +140,32 @@ declare function runInOperationContext<T>(name: string, fn: () => T): T;
  * Uses token bucket algorithm for smooth rate limiting with burst capacity.
  */
 interface RateLimiterConfig {
-    /** Maximum events per second (default: 100) */
-    maxEventsPerSecond: number;
-    /** Burst capacity - max events in a single burst (default: 2x rate) */
-    burstCapacity?: number;
+  /** Maximum events per second (default: 100) */
+  maxEventsPerSecond: number;
+  /** Burst capacity - max events in a single burst (default: 2x rate) */
+  burstCapacity?: number;
 }
-
-/**
- * Events event queue with batching, backpressure, retry logic, rate limiting, and OTel metrics
- *
- * Exposes delivery pipeline metrics for observability:
- * - autotel.event_delivery.queue.size - Current queue size
- * - autotel.event_delivery.queue.oldest_age_ms - Age of oldest event in queue
- * - autotel.event_delivery.queue.delivered - Successfully delivered events
- * - autotel.event_delivery.queue.failed - Failed event deliveries
- * - autotel.event_delivery.queue.dropped - Dropped events with reason
- * - autotel.event_delivery.queue.latency_ms - Delivery latency histogram
- * - autotel.event_delivery.subscriber.health - Subscriber health (1=healthy, 0=unhealthy)
- */
-
+//#endregion
+//#region src/event-queue.d.ts
 interface EventData {
-    name: string;
-    attributes?: EventAttributes;
-    timestamp: number;
-    /** Internal: correlation ID for debug breadcrumbs */
-    _correlationId?: string;
-    /** Internal: trace ID for debug breadcrumbs */
-    _traceId?: string;
-    /** Autotel context for trace correlation (passed to subscribers) */
-    autotel?: AutotelEventContext;
-    /** Optional schema metadata for contract-aware subscribers. */
-    schema?: EventSchemaMetadata;
+  name: string;
+  attributes?: EventAttributes;
+  timestamp: number;
+  /** Internal: correlation ID for debug breadcrumbs */
+  _correlationId?: string;
+  /** Internal: trace ID for debug breadcrumbs */
+  _traceId?: string;
+  /** Autotel context for trace correlation (passed to subscribers) */
+  autotel?: AutotelEventContext;
+  /** Optional schema metadata for contract-aware subscribers. */
+  schema?: EventSchemaMetadata;
 }
 interface QueueConfig {
-    maxSize: number;
-    batchSize: number;
-    flushInterval: number;
-    maxRetries: number;
-    rateLimit?: RateLimiterConfig;
+  maxSize: number;
+  batchSize: number;
+  flushInterval: number;
+  maxRetries: number;
+  rateLimit?: RateLimiterConfig;
 }
 /**
  * Events queue with batching and backpressure
@@ -224,118 +178,113 @@ interface QueueConfig {
  * - Graceful flush on shutdown
  */
 declare class EventQueue {
-    private queue;
-    private flushTimer;
-    private readonly config;
-    private readonly subscribers;
-    private readonly rateLimiter;
-    private flushPromise;
-    private isShuttingDown;
-    private metrics;
-    private observableCleanups;
-    private subscriberHealthy;
-    constructor(subscribers: EventSubscriber[], config?: Partial<QueueConfig>);
-    /**
-     * Initialize OTel metrics for queue observability
-     */
-    private initMetrics;
-    /**
-     * Record a dropped event with reason and emit debug breadcrumb
-     */
-    private recordDropped;
-    /**
-     * Record permanent delivery failure (after all retries exhausted)
-     * Increments failed counter and logs error
-     */
-    private recordFailed;
-    /**
-     * Mark subscriber as unhealthy on transient failure (without incrementing failed counter)
-     * Used during retry attempts - only recordFailed should increment the counter
-     */
-    private markSubscriberUnhealthy;
-    /**
-     * Record successful delivery
-     */
-    private recordDelivered;
-    /**
-     * Enqueue an event for sending
-     *
-     * Backpressure policy:
-     * - Drops oldest event and logs warning if queue is full (same behavior in all environments)
-     */
-    enqueue(event: EventData): void;
-    /**
-     * Schedule a batch flush if not already scheduled
-     */
-    private scheduleBatchFlush;
-    /**
-     * Flush a batch of events
-     * Uses promise-based concurrency control to prevent race conditions
-     */
-    private flushBatch;
-    /**
-     * Internal flush implementation
-     */
-    private doFlushBatch;
-    /**
-     * Send events with exponential backoff retry
-     * Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.
-     * On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.
-     */
-    private sendWithRetry;
-    /**
-     * Send events to configured subscribers with rate limiting and metrics.
-     * When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.
-     * Returns per-event, per-subscriber failures (empty if all succeeded).
-     */
-    private sendToSubscribers;
-    /**
-     * Send a single event to subscribers.
-     * - When subscriberNames is undefined (initial attempt): send to all subscribers.
-     * - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).
-     * Returns list of subscribers that failed (empty if all succeeded).
-     */
-    private sendEventToSubscribers;
-    /**
-     * Flush all remaining events. Queue remains usable after flush (e.g. for
-     * auto-flush at root span end). Use shutdown() when tearing down the queue.
-     */
-    flush(): Promise<void>;
-    /**
-     * Flush remaining events and permanently disable the queue (reject new events).
-     * Use for process/SDK shutdown; use flush() for periodic or span-end drain.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Cleanup observable metric callbacks to prevent memory leaks
-     * Call this when destroying the EventQueue instance
-     */
-    cleanup(): void;
-    /**
-     * Get queue size (for testing/debugging)
-     */
-    size(): number;
-    /**
-     * Get subscriber health status (for testing/debugging)
-     */
-    getSubscriberHealth(): Map<string, boolean>;
-    /**
-     * Check if a specific subscriber is healthy
-     */
-    isSubscriberHealthy(subscriberName: string): boolean;
-    /**
-     * Manually mark a subscriber as healthy or unhealthy
-     * (used for circuit breaker integration)
-     */
-    setSubscriberHealth(subscriberName: string, healthy: boolean): void;
-}
-
-/**
- * Global track() function for business events
- *
- * Simple, no instantiation needed, auto-attaches trace context
- */
-
+  private queue;
+  private flushTimer;
+  private readonly config;
+  private readonly subscribers;
+  private readonly rateLimiter;
+  private flushPromise;
+  private isShuttingDown;
+  private metrics;
+  private observableCleanups;
+  private subscriberHealthy;
+  constructor(subscribers: EventSubscriber[], config?: Partial<QueueConfig>);
+  /**
+   * Initialize OTel metrics for queue observability
+   */
+  private initMetrics;
+  /**
+   * Record a dropped event with reason and emit debug breadcrumb
+   */
+  private recordDropped;
+  /**
+   * Record permanent delivery failure (after all retries exhausted)
+   * Increments failed counter and logs error
+   */
+  private recordFailed;
+  /**
+   * Mark subscriber as unhealthy on transient failure (without incrementing failed counter)
+   * Used during retry attempts - only recordFailed should increment the counter
+   */
+  private markSubscriberUnhealthy;
+  /**
+   * Record successful delivery
+   */
+  private recordDelivered;
+  /**
+   * Enqueue an event for sending
+   *
+   * Backpressure policy:
+   * - Drops oldest event and logs warning if queue is full (same behavior in all environments)
+   */
+  enqueue(event: EventData): void;
+  /**
+   * Schedule a batch flush if not already scheduled
+   */
+  private scheduleBatchFlush;
+  /**
+   * Flush a batch of events
+   * Uses promise-based concurrency control to prevent race conditions
+   */
+  private flushBatch;
+  /**
+   * Internal flush implementation
+   */
+  private doFlushBatch;
+  /**
+   * Send events with exponential backoff retry
+   * Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.
+   * On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.
+   */
+  private sendWithRetry;
+  /**
+   * Send events to configured subscribers with rate limiting and metrics.
+   * When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.
+   * Returns per-event, per-subscriber failures (empty if all succeeded).
+   */
+  private sendToSubscribers;
+  /**
+   * Send a single event to subscribers.
+   * - When subscriberNames is undefined (initial attempt): send to all subscribers.
+   * - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).
+   * Returns list of subscribers that failed (empty if all succeeded).
+   */
+  private sendEventToSubscribers;
+  /**
+   * Flush all remaining events. Queue remains usable after flush (e.g. for
+   * auto-flush at root span end). Use shutdown() when tearing down the queue.
+   */
+  flush(): Promise<void>;
+  /**
+   * Flush remaining events and permanently disable the queue (reject new events).
+   * Use for process/SDK shutdown; use flush() for periodic or span-end drain.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Cleanup observable metric callbacks to prevent memory leaks
+   * Call this when destroying the EventQueue instance
+   */
+  cleanup(): void;
+  /**
+   * Get queue size (for testing/debugging)
+   */
+  size(): number;
+  /**
+   * Get subscriber health status (for testing/debugging)
+   */
+  getSubscriberHealth(): Map<string, boolean>;
+  /**
+   * Check if a specific subscriber is healthy
+   */
+  isSubscriberHealthy(subscriberName: string): boolean;
+  /**
+   * Manually mark a subscriber as healthy or unhealthy
+   * (used for circuit breaker integration)
+   */
+  setSubscriberHealth(subscriberName: string, healthy: boolean): void;
+}
+//#endregion
+//#region src/track.d.ts
 /**
  * Track a business events event
  *
@@ -377,7 +326,8 @@ declare function track<Events extends Record<string, any> = Record<string, any>>
  * @internal
  */
 declare function getEventQueue(): EventQueue | null;
-
+//#endregion
+//#region src/shutdown.d.ts
 /**
  * Graceful shutdown with flush and cleanup
  */
@@ -410,8 +360,8 @@ declare function getEventQueue(): EventQueue | null;
  * ```
  */
 declare function flush(options?: {
-    timeout?: number;
-    forShutdown?: boolean;
+  timeout?: number;
+  forShutdown?: boolean;
 }): Promise<void>;
 /**
  * Shutdown telemetry and cleanup resources
@@ -437,147 +387,137 @@ declare function flush(options?: {
  * ```
  */
 declare function shutdown(): Promise<void>;
-
-declare function runWithRequestContext<T>(ctx: TraceContext, fn: () => T): T;
+//#endregion
+//#region src/request-logger.d.ts
+declare function runWithRequestContext<T>(ctx: TraceContext$1, fn: () => T): T;
 interface RequestLogger {
-    set(fields: Record<string, unknown>): void;
-    info(message: string, fields?: Record<string, unknown>): void;
-    warn(message: string, fields?: Record<string, unknown>): void;
-    error(error: Error | string, fields?: Record<string, unknown>): void;
-    getContext(): Record<string, unknown>;
-    emitNow(overrides?: Record<string, unknown>): RequestLogSnapshot;
-    fork(label: string, fn: () => void | Promise<void>, options?: ForkOptions): void;
+  set(fields: Record<string, unknown>): void;
+  info(message: string, fields?: Record<string, unknown>): void;
+  warn(message: string, fields?: Record<string, unknown>): void;
+  error(error: Error | string, fields?: Record<string, unknown>): void;
+  getContext(): Record<string, unknown>;
+  emitNow(overrides?: Record<string, unknown>): RequestLogSnapshot;
+  fork(label: string, fn: () => void | Promise<void>, options?: ForkOptions): void;
 }
 interface RequestLogSnapshot {
-    timestamp: string;
-    traceId: string;
-    spanId: string;
-    correlationId: string;
-    context: Record<string, unknown>;
+  timestamp: string;
+  traceId: string;
+  spanId: string;
+  correlationId: string;
+  context: Record<string, unknown>;
 }
 interface RequestLoggerOptions {
-    /** Callback invoked by emitNow() for manual fan-out. */
-    onEmit?: (snapshot: RequestLogSnapshot) => void | Promise<void>;
+  /** Callback invoked by emitNow() for manual fan-out. */
+  onEmit?: (snapshot: RequestLogSnapshot) => void | Promise<void>;
 }
 /**
  * Optional lifecycle hooks for adapters that need to track child loggers
  * spawned by `log.fork()` (e.g. active logger maps in framework integrations).
  */
 interface ForkLifecycle {
-    /** Called after the child logger is created, before `fn` runs. */
-    onChildEnter?: (child: RequestLogger) => void;
-    /** Called after the child has finished (emit + drain), success or failure. */
-    onChildExit?: (child: RequestLogger) => void;
+  /** Called after the child logger is created, before `fn` runs. */
+  onChildEnter?: (child: RequestLogger) => void;
+  /** Called after the child has finished (emit + drain), success or failure. */
+  onChildExit?: (child: RequestLogger) => void;
 }
 interface ForkOptions {
-    lifecycle?: ForkLifecycle;
+  lifecycle?: ForkLifecycle;
 }
-declare function getRequestLogger(ctx?: TraceContext, options?: RequestLoggerOptions): RequestLogger;
-
+declare function getRequestLogger(ctx?: TraceContext$1, options?: RequestLoggerOptions): RequestLogger;
+/**
+ * Returns `true` when a request-logger context can be resolved without throwing —
+ * i.e. an explicit `ctx` was provided, a `runWithRequestContext()` scope is active,
+ * or there is an active OpenTelemetry span.
+ *
+ * Use this to branch on observability availability instead of wrapping
+ * {@link getRequestLogger} in try/catch.
+ */
+declare function hasRequestContext(ctx?: TraceContext$1): boolean;
+/**
+ * Like {@link getRequestLogger}, but returns `null` instead of throwing when no
+ * request context is available. Intended for best-effort instrumentation where a
+ * missing telemetry context must never crash business logic.
+ */
+declare function getRequestLoggerSafe(ctx?: TraceContext$1, options?: RequestLoggerOptions): RequestLogger | null;
+/**
+ * A no-op {@link RequestLogger} whose methods do nothing. Used as a fallback by
+ * best-effort instrumentation so wrapped handlers can run un-instrumented without
+ * branching on logger presence.
+ */
+declare function createNoopRequestLogger(): RequestLogger;
+//#endregion
+//#region src/structured-error.d.ts
 interface StructuredErrorInput {
-    message: string;
-    why?: string;
-    fix?: string;
-    link?: string;
-    code?: string | number;
-    status?: number;
-    cause?: unknown;
-    details?: Record<string, unknown>;
-    name?: string;
-    /** Backend-only context. Omitted from toJSON() and never serialized to clients. */
-    internal?: Record<string, unknown>;
+  message: string;
+  why?: string;
+  fix?: string;
+  link?: string;
+  code?: string | number;
+  status?: number;
+  cause?: unknown;
+  details?: Record<string, unknown>;
+  name?: string;
+  /** Backend-only context. Omitted from toJSON() and never serialized to clients. */
+  internal?: Record<string, unknown>;
 }
 interface StructuredError extends Error {
-    why?: string;
-    fix?: string;
-    link?: string;
-    code?: string | number;
-    status?: number;
-    details?: Record<string, unknown>;
-    /** Backend-only context. Omitted from toJSON() and never serialized to clients. */
-    readonly internal?: Record<string, unknown>;
+  why?: string;
+  fix?: string;
+  link?: string;
+  code?: string | number;
+  status?: number;
+  details?: Record<string, unknown>;
+  /** Backend-only context. Omitted from toJSON() and never serialized to clients. */
+  readonly internal?: Record<string, unknown>;
 }
 declare function createStructuredError(input: StructuredErrorInput): StructuredError;
 declare function structuredErrorToJSON(error: StructuredError): Record<string, unknown>;
-declare function getStructuredErrorAttributes(error: Error): Record<string, AttributeValue>;
-declare function recordStructuredError(ctx: Pick<TraceContext, 'setAttributes' | 'setStatus'>, error: Error): void;
-
-/**
- * Typed error and audit catalogs.
- *
- * Group related errors into one catalog and get a refactor-safe builder per
- * code, with autocomplete at every call site and typed message parameters.
- *
- * @example
- * ```typescript
- * import { defineErrorCatalog } from 'autotel';
- *
- * export const billing = defineErrorCatalog('billing', {
- *   PAYMENT_DECLINED: {
- *     status: 402,
- *     message: 'Card declined',
- *     why: 'The issuer rejected the charge',
- *     fix: 'Try a different payment method',
- *   },
- *   INSUFFICIENT_FUNDS: {
- *     status: 402,
- *     message: ({ available, required }: { available: number; required: number }) =>
- *       `Insufficient funds: $${available} of $${required}`,
- *   },
- * });
- *
- * throw billing.PAYMENT_DECLINED({ cause: stripeError });
- * throw billing.INSUFFICIENT_FUNDS({ available: 5, required: 100 });
- *
- * // In a catch block — refactor-safe, no magic strings:
- * if (billing.PAYMENT_DECLINED.match(err)) { ... }
- * ```
- */
-
+declare function getStructuredErrorAttributes(error: Error): Record<string, AttributeValue$2>;
+declare function recordStructuredError(ctx: Pick<TraceContext$1, 'setAttributes' | 'setStatus'>, error: Error): void;
+//#endregion
+//#region src/error-catalog.d.ts
 /** Definition of a single error in a catalog. */
 interface ErrorCatalogEntry {
-    /**
-     * Human-readable message. Use a function to interpolate typed parameters;
-     * the parameter type flows through to the call site.
-     */
-    message: string | ((params: never) => string);
-    /** HTTP status to surface to clients. */
-    status?: number;
-    /** Stable error code. Defaults to `${namespace}.${KEY}`. */
-    code?: string | number;
-    /** Why it happened. A function receives the same params as `message`. */
-    why?: string | ((params: never) => string);
-    /** What the caller should do next. */
-    fix?: string;
-    /** Docs or runbook link. */
-    link?: string;
-    /** Error name. Defaults to the catalog key. */
-    name?: string;
+  /**
+   * Human-readable message. Use a function to interpolate typed parameters;
+   * the parameter type flows through to the call site.
+   */
+  message: string | ((params: never) => string);
+  /** HTTP status to surface to clients. */
+  status?: number;
+  /** Stable error code. Defaults to `${namespace}.${KEY}`. */
+  code?: string | number;
+  /** Why it happened. A function receives the same params as `message`. */
+  why?: string | ((params: never) => string);
+  /** What the caller should do next. */
+  fix?: string;
+  /** Docs or runbook link. */
+  link?: string;
+  /** Error name. Defaults to the catalog key. */
+  name?: string;
 }
 /** Per-call options passed alongside (or instead of) typed params. */
 interface ErrorBuildOptions {
-    cause?: unknown;
-    details?: Record<string, unknown>;
-    /** Backend-only context. Never serialized to clients. */
-    internal?: Record<string, unknown>;
+  cause?: unknown;
+  details?: Record<string, unknown>;
+  /** Backend-only context. Never serialized to clients. */
+  internal?: Record<string, unknown>;
 }
 type ParamsOf<E> = E extends {
-    message: (params: infer P) => string;
+  message: (params: infer P) => string;
 } ? P : E extends {
-    why: (params: infer P) => string;
+  why: (params: infer P) => string;
 } ? P : void;
 type BuilderArgs<E extends ErrorCatalogEntry> = ParamsOf<E> extends void ? [options?: ErrorBuildOptions] : [params: ParamsOf<E>, options?: ErrorBuildOptions];
 /** A callable error factory produced by {@link defineErrorCatalog}. */
 interface ErrorBuilder<E extends ErrorCatalogEntry> {
-    (...args: BuilderArgs<E>): StructuredError;
-    /** Stable code assigned to every error from this entry. */
-    readonly code: string | number;
-    /** True when `error` was produced by this catalog entry. */
-    match(error: unknown): boolean;
-}
-type ErrorCatalog<T extends Record<string, ErrorCatalogEntry>> = {
-    readonly [K in keyof T]: ErrorBuilder<T[K]>;
-};
+  (...args: BuilderArgs<E>): StructuredError;
+  /** Stable code assigned to every error from this entry. */
+  readonly code: string | number;
+  /** True when `error` was produced by this catalog entry. */
+  match(error: unknown): boolean;
+}
+type ErrorCatalog<T extends Record<string, ErrorCatalogEntry>> = { readonly [K in keyof T]: ErrorBuilder<T[K]> };
 /** True when `error` was produced by any autotel error catalog. */
 declare function isCatalogError(error: unknown): error is StructuredError;
 /** Returns the catalog code of `error`, or `undefined` if it has none. */
@@ -592,97 +532,99 @@ declare function defineErrorCatalog<const T extends Record<string, ErrorCatalogE
 type AuditSeverity = 'info' | 'warn' | 'critical';
 /** Definition of a single action in an audit catalog. */
 interface AuditCatalogEntry {
-    /** Human-readable description. Use a function for typed params. */
-    message?: string | ((params: never) => string);
-    /** Stable action name. Defaults to `${namespace}.${KEY}`. */
-    action?: string;
-    /** Severity of the action. Defaults to `'info'`. */
-    severity?: AuditSeverity;
+  /** Human-readable description. Use a function for typed params. */
+  message?: string | ((params: never) => string);
+  /** Stable action name. Defaults to `${namespace}.${KEY}`. */
+  action?: string;
+  /** Severity of the action. Defaults to `'info'`. */
+  severity?: AuditSeverity;
 }
 /** A resolved audit action descriptor produced by an audit catalog. */
 interface AuditAction {
-    readonly action: string;
-    readonly severity: AuditSeverity;
-    readonly message?: string;
+  readonly action: string;
+  readonly severity: AuditSeverity;
+  readonly message?: string;
 }
 type AuditDescriptorArgs<E extends AuditCatalogEntry> = ParamsOf<E> extends void ? [] : [params: ParamsOf<E>];
 /** A callable audit-action descriptor produced by {@link defineAuditCatalog}. */
 interface AuditDescriptor<E extends AuditCatalogEntry> {
-    (...args: AuditDescriptorArgs<E>): AuditAction;
-    readonly action: string;
-    readonly severity: AuditSeverity;
+  (...args: AuditDescriptorArgs<E>): AuditAction;
+  readonly action: string;
+  readonly severity: AuditSeverity;
 }
-type AuditCatalog<T extends Record<string, AuditCatalogEntry>> = {
-    readonly [K in keyof T]: AuditDescriptor<T[K]>;
-};
+type AuditCatalog<T extends Record<string, AuditCatalogEntry>> = { readonly [K in keyof T]: AuditDescriptor<T[K]> };
 /**
  * Define a typed audit catalog. Returns typed action descriptors you can pass
  * to `track()` or audit helpers without scattering magic strings.
  */
 declare function defineAuditCatalog<const T extends Record<string, AuditCatalogEntry>>(namespace: string, entries: T): AuditCatalog<T>;
-
+//#endregion
+//#region src/flatten-attributes.d.ts
 /**
  * Convert an unknown value to an OTel-compatible AttributeValue.
  * Returns undefined when the value cannot be represented.
  */
-declare function toAttributeValue(value: unknown): AttributeValue | undefined;
+declare function toAttributeValue(value: unknown): AttributeValue$2 | undefined;
 /**
  * Recursively flatten a nested object into dot-notation OTel attributes.
  * Includes circular reference protection via WeakSet.
  */
-declare function flattenToAttributes(fields: Record<string, unknown>, prefix?: string): Record<string, AttributeValue>;
-
+declare function flattenToAttributes(fields: Record<string, unknown>, prefix?: string): Record<string, AttributeValue$2>;
+//#endregion
+//#region src/drain-toolkit.d.ts
 interface DrainOptions<TContext, TConfig, TPayload = TContext> {
-    /** Stable identifier used in error logs. */
-    name: string;
-    /** Return null to skip draining (e.g. missing API key in dev). */
-    resolve: () => TConfig | null | Promise<TConfig | null>;
-    /** Transform contexts into payloads. Defaults to identity. */
-    transform?: (contexts: TContext[]) => TPayload[];
-    /** Transport implementation. */
-    send: (payloads: TPayload[], config: TConfig) => Promise<void>;
+  /** Stable identifier used in error logs. */
+  name: string;
+  /** Return null to skip draining (e.g. missing API key in dev). */
+  resolve: () => TConfig | null | Promise<TConfig | null>;
+  /** Transform contexts into payloads. Defaults to identity. */
+  transform?: (contexts: TContext[]) => TPayload[];
+  /** Transport implementation. */
+  send: (payloads: TPayload[], config: TConfig) => Promise<void>;
 }
 interface HttpDrainRequest {
-    url: string;
-    headers: Record<string, string>;
-    body: string;
+  url: string;
+  headers: Record<string, string>;
+  body: string;
 }
 interface HttpDrainOptions<TContext, TConfig, TPayload = TContext> extends Omit<DrainOptions<TContext, TConfig, TPayload>, 'send'> {
-    encode: (payloads: TPayload[], config: TConfig) => HttpDrainRequest | null;
-    timeoutMs?: number;
-    retries?: number;
-    resolveTimeoutMs?: (config: TConfig) => number | undefined;
-    resolveRetries?: (config: TConfig) => number | undefined;
+  encode: (payloads: TPayload[], config: TConfig) => HttpDrainRequest | null;
+  timeoutMs?: number;
+  retries?: number;
+  resolveTimeoutMs?: (config: TConfig) => number | undefined;
+  resolveRetries?: (config: TConfig) => number | undefined;
 }
 declare function defineDrain<TContext, TConfig, TPayload = TContext>(options: DrainOptions<TContext, TConfig, TPayload>): (ctx: TContext | TContext[]) => Promise<void>;
 declare function defineHttpDrain<TContext, TConfig, TPayload = TContext>(options: HttpDrainOptions<TContext, TConfig, TPayload>): (ctx: TContext | TContext[]) => Promise<void>;
-
+//#endregion
+//#region src/enricher-toolkit.d.ts
 interface EnrichContext<TEvent extends Record<string, unknown>> {
-    event: TEvent;
-    request?: {
-        method?: string;
-        path?: string;
-        requestId?: string;
-    };
-    response?: {
-        status?: number;
-    };
-    headers?: Record<string, string>;
+  event: TEvent;
+  request?: {
+    method?: string;
+    path?: string;
+    requestId?: string;
+  };
+  response?: {
+    status?: number;
+  };
+  headers?: Record<string, string>;
 }
 interface EnricherDefinition<TEvent extends Record<string, unknown>, TValue extends object> {
-    /** Stable identifier used in error logs. */
-    name: string;
-    /** Top-level field to merge computed values into. */
-    field: keyof TEvent & string;
-    /** Return undefined to skip enrichment. */
-    compute: (ctx: EnrichContext<TEvent>) => TValue | undefined;
+  /** Stable identifier used in error logs. */
+  name: string;
+  /** Top-level field to merge computed values into. */
+  field: keyof TEvent & string;
+  /** Return undefined to skip enrichment. */
+  compute: (ctx: EnrichContext<TEvent>) => TValue | undefined;
 }
 interface EnricherOptions {
-    /** Replace existing field value instead of merge. Default false. */
-    overwrite?: boolean;
+  /** Replace existing field value instead of merge. Default false. */
+  overwrite?: boolean;
 }
 declare function defineEnricher<TEvent extends Record<string, unknown>, TValue extends object>(def: EnricherDefinition<TEvent, TValue>, options?: EnricherOptions): (ctx: EnrichContext<TEvent>) => void;
-
+//#endregion
+//#region src/pretty-log-formatter.d.ts
 /**
  * Format milliseconds into a human-readable duration string.
  *
@@ -692,38 +634,8 @@ declare function defineEnricher<TEvent extends Record<string, unknown>, TValue e
  * formatDuration(65000)  // "1m 5s"
  */
 declare function formatDuration(ms: number): string;
-
-/**
- * LLM-tuned histogram buckets.
- *
- * Default OpenTelemetry histogram buckets target HTTP latency (0ms–10s)
- * and small counter values. LLM workloads have very different shapes:
- *
- *   - **Duration**: single-token prompts can be fast (50ms), long
- *     generations and reasoning models can run for minutes. Default buckets
- *     crush everything above 10s into one bucket.
- *   - **Token usage**: heavily right-skewed. A single request can range
- *     from tens of tokens to the million-token context windows.
- *   - **Cost (USD)**: per-request values are tiny (fractions of a cent),
- *     so linear buckets waste resolution at the low end.
- *
- * This module exposes empirically-chosen bucket arrays and a View helper
- * so users can apply them to their `MeterProvider` without knowing the
- * exact instrument names emitted by OpenAI/Anthropic/Traceloop plugins.
- *
- * @example
- * ```typescript
- * import { NodeSDK } from '@opentelemetry/sdk-node';
- * import { genAiMetricViews } from 'autotel';
- *
- * const sdk = new NodeSDK({
- *   serviceName: 'my-agent',
- *   views: [...genAiMetricViews()],
- * });
- * sdk.start();
- * ```
- */
-
+//#endregion
+//#region src/gen-ai-metrics.d.ts
 /**
  * Duration buckets for LLM operations, in **seconds**. Covers fast
  * completions (50ms) through long-running reasoning jobs (5 min).
@@ -752,9 +664,9 @@ declare const GEN_AI_COST_USD_BUCKETS: readonly number[];
  * from a third-party plugin.
  */
 declare function llmHistogramAdvice(kind: 'duration' | 'tokens' | 'cost'): {
-    advice: {
-        explicitBucketBoundaries: number[];
-    };
+  advice: {
+    explicitBucketBoundaries: number[];
+  };
 };
 /**
  * Returns `View`s that re-bucket the standard OTel GenAI histograms. Pass
@@ -769,169 +681,106 @@ declare function llmHistogramAdvice(kind: 'duration' | 'tokens' | 'cost'): {
  * custom LLM metrics.
  */
 declare function genAiMetricViews(extra?: {
-    instrumentName: string;
-    kind: 'duration' | 'tokens' | 'cost';
+  instrumentName: string;
+  kind: 'duration' | 'tokens' | 'cost';
 }[]): ViewOptions[];
-
-/**
- * Span event helpers for LLM lifecycle, aligned with the OpenTelemetry
- * GenAI semantic conventions.
- *
- * Span events are timestamped points within a span — they render as dots
- * on the trace timeline in Jaeger / Tempo / Langfuse / Arize. Use them
- * to mark lifecycle moments the span attributes alone can't express:
- *
- *   - When the prompt was sent (vs. when the first token arrived)
- *   - When each retry attempt started, and why
- *   - When a streaming response produced its first token (TTFT)
- *   - When a tool was invoked
- *
- * Every helper pins the event name + attribute keys to the published
- * spec so downstream tooling (autotel-mcp, Langfuse, vendor UIs) can
- * render them consistently.
- *
- * @example
- * ```typescript
- * import { trace, recordPromptSent, recordResponseReceived, recordRetry } from 'autotel';
- *
- * export const chat = trace('chat', ctx => async (prompt: string) => {
- *   recordPromptSent(ctx, { model: 'gpt-4o', messageCount: 1 });
- *
- *   for (let attempt = 1; attempt <= 3; attempt++) {
- *     try {
- *       const res = await openai.chat.completions.create({...});
- *       recordResponseReceived(ctx, {
- *         model: res.model,
- *         promptTokens: res.usage?.prompt_tokens,
- *         completionTokens: res.usage?.completion_tokens,
- *         finishReasons: res.choices.map(c => c.finish_reason),
- *       });
- *       return res;
- *     } catch (err) {
- *       recordRetry(ctx, { attempt, reason: 'rate_limit', delayMs: 500 });
- *       await sleep(500 * attempt);
- *     }
- *   }
- * });
- * ```
- */
-
+//#endregion
+//#region src/gen-ai-events.d.ts
 /** Attributes expected on a `gen_ai.prompt.sent` event. */
 interface PromptSentEvent {
-    /** Model the caller intends to invoke (may differ from response model). */
-    model?: string;
-    /** Estimated input token count, when known before the call. */
-    promptTokens?: number;
-    /** Number of messages in a chat request (system + user + assistant). */
-    messageCount?: number;
-    /** Free-form operation kind — `chat` / `completion` / `embedding`. */
-    operation?: string;
+  /** Model the caller intends to invoke (may differ from response model). */
+  model?: string;
+  /** Estimated input token count, when known before the call. */
+  promptTokens?: number;
+  /** Number of messages in a chat request (system + user + assistant). */
+  messageCount?: number;
+  /** Free-form operation kind — `chat` / `completion` / `embedding`. */
+  operation?: string;
 }
 /** Attributes expected on a `gen_ai.response.received` event. */
 interface ResponseReceivedEvent {
-    /** Model the provider actually served (may be more specific than requested). */
-    model?: string;
-    promptTokens?: number;
-    completionTokens?: number;
-    totalTokens?: number;
-    /** `stop`, `length`, `content_filter`, `tool_calls`, etc. */
-    finishReasons?: string[];
+  /** Model the provider actually served (may be more specific than requested). */
+  model?: string;
+  promptTokens?: number;
+  completionTokens?: number;
+  totalTokens?: number;
+  /** `stop`, `length`, `content_filter`, `tool_calls`, etc. */
+  finishReasons?: string[];
 }
 /** Attributes expected on a `gen_ai.retry` event. */
 interface RetryEvent {
-    attempt: number;
-    /** `rate_limit` | `timeout` | `provider_error` | custom label. */
-    reason?: string;
-    /** How long we'll wait before the next attempt. */
-    delayMs?: number;
-    /** HTTP status that triggered the retry, when applicable. */
-    statusCode?: number;
+  attempt: number;
+  /** `rate_limit` | `timeout` | `provider_error` | custom label. */
+  reason?: string;
+  /** How long we'll wait before the next attempt. */
+  delayMs?: number;
+  /** HTTP status that triggered the retry, when applicable. */
+  statusCode?: number;
 }
 /** Attributes expected on a `gen_ai.tool.call` event. */
 interface ToolCallEvent {
-    toolName: string;
-    /** Call identifier so responses can be correlated back to calls. */
-    toolCallId?: string;
-    /** Pre-serialised tool arguments; omit if sensitive. */
-    arguments?: string;
+  toolName: string;
+  /** Call identifier so responses can be correlated back to calls. */
+  toolCallId?: string;
+  /** Pre-serialised tool arguments; omit if sensitive. */
+  arguments?: string;
 }
 /** Attributes expected on a `gen_ai.stream.first_token` event. */
 interface StreamFirstTokenEvent {
-    /** Tokens streamed so far, if the caller tracks that. */
-    tokensSoFar?: number;
+  /** Tokens streamed so far, if the caller tracks that. */
+  tokensSoFar?: number;
 }
 /**
  * Record that a prompt was dispatched to the provider. Typically called
  * before `await provider.chat.completions.create(...)`.
  */
-declare function recordPromptSent(ctx: TraceContext, event?: PromptSentEvent): void;
+declare function recordPromptSent(ctx: TraceContext$1, event?: PromptSentEvent): void;
 /**
  * Record a successful provider response. Call after the response arrives
  * (for non-streaming) or after the stream completes.
  */
-declare function recordResponseReceived(ctx: TraceContext, event?: ResponseReceivedEvent): void;
+declare function recordResponseReceived(ctx: TraceContext$1, event?: ResponseReceivedEvent): void;
 /**
  * Record a retry attempt on an LLM call. Call *before* sleeping for
  * `delayMs` so the event timestamp accurately marks when the retry
  * decision was made.
  */
-declare function recordRetry(ctx: TraceContext, event: RetryEvent): void;
+declare function recordRetry(ctx: TraceContext$1, event: RetryEvent): void;
 /**
  * Record a tool / function call made in the course of an agent step.
  * Emits an event rather than a child span because many frameworks fire
  * several tool calls within a single provider response.
  */
-declare function recordToolCall(ctx: TraceContext, event: ToolCallEvent): void;
+declare function recordToolCall(ctx: TraceContext$1, event: ToolCallEvent): void;
 /**
  * Record the time-to-first-token for a streaming response. Pair with
  * `recordResponseReceived` at the end so the span carries both the TTFT
  * marker and the final usage numbers.
  */
-declare function recordStreamFirstToken(ctx: TraceContext, event?: StreamFirstTokenEvent): void;
-
-/**
- * Per-model LLM cost estimation.
- *
- * Estimate the USD cost of an LLM call from its token usage and record it as a
- * span attribute (`gen_ai.usage.cost.usd`). Pair with the
- * `gen_ai.client.cost.usd` metric bucket advice in `gen-ai-metrics`.
- *
- * @example
- * ```typescript
- * import { trace, recordLLMCost } from 'autotel';
- *
- * export const chat = trace((ctx) => async (prompt: string) => {
- *   const res = await client.messages.create({ model, ... });
- *   recordLLMCost(ctx, model, {
- *     inputTokens: res.usage.input_tokens,
- *     outputTokens: res.usage.output_tokens,
- *   });
- *   return res;
- * });
- * ```
- */
-
+declare function recordStreamFirstToken(ctx: TraceContext$1, event?: StreamFirstTokenEvent): void;
+//#endregion
+//#region src/gen-ai-cost.d.ts
 /** Span attribute key autotel sets for an estimated call cost. */
 declare const GEN_AI_COST_ATTRIBUTE = "gen_ai.usage.cost.usd";
 /** Pricing for a single model, in USD per 1,000,000 tokens. */
 interface ModelPricing {
-    /** USD per 1M input (prompt) tokens. */
-    inputPer1M: number;
-    /** USD per 1M output (completion) tokens. */
-    outputPer1M: number;
-    /** USD per 1M cached input tokens. Defaults to {@link ModelPricing.inputPer1M}. */
-    cachedInputPer1M?: number;
+  /** USD per 1M input (prompt) tokens. */
+  inputPer1M: number;
+  /** USD per 1M output (completion) tokens. */
+  outputPer1M: number;
+  /** USD per 1M cached input tokens. Defaults to {@link ModelPricing.inputPer1M}. */
+  cachedInputPer1M?: number;
 }
 /** Token counts for a single LLM call. */
 interface TokenUsage {
-    inputTokens?: number;
-    outputTokens?: number;
-    /** Cached input tokens, billed at {@link ModelPricing.cachedInputPer1M}. */
-    cachedInputTokens?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  /** Cached input tokens, billed at {@link ModelPricing.cachedInputPer1M}. */
+  cachedInputTokens?: number;
 }
 interface EstimateCostOptions {
-    /** Override or extend {@link MODEL_PRICING}. Keys are matched first. */
-    pricing?: Record<string, ModelPricing>;
+  /** Override or extend {@link MODEL_PRICING}. Keys are matched first. */
+  pricing?: Record<string, ModelPricing>;
 }
 /**
  * Approximate public list prices (USD per 1M tokens) at the time of writing.
@@ -951,6 +800,7 @@ declare function estimateLLMCost(model: string, usage: TokenUsage, options?: Est
  * attribute. Returns the estimated cost, or `undefined` when the model is
  * unknown (in which case no attribute is set).
  */
-declare function recordLLMCost(ctx: Pick<TraceContext, 'setAttribute'>, model: string, usage: TokenUsage, options?: EstimateCostOptions): number | undefined;
-
-export { AttributeRedactorConfig, AttributeRedactorPreset, type AuditAction, type AuditCatalog, type AuditCatalogEntry, type AuditDescriptor, type AuditSeverity, BaggageSpanProcessor, type BaggageSpanProcessorOptions, type DrainOptions, type EnrichContext, type EnricherDefinition, type EnricherOptions, type ErrorBuildOptions, type ErrorBuilder, type ErrorCatalog, type ErrorCatalogEntry, type EstimateCostOptions, EventAttributes, EventSubscriber, type ForkLifecycle, type ForkOptions, GEN_AI_COST_ATTRIBUTE, GEN_AI_COST_USD_BUCKETS, GEN_AI_DURATION_BUCKETS_SECONDS, GEN_AI_TOKEN_USAGE_BUCKETS, type HttpDrainOptions, type HttpDrainRequest, MODEL_PRICING, type ModelPricing, type OperationContext, type PromptSentEvent, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, type ResponseReceivedEvent, type RetryEvent, type StreamFirstTokenEvent, type StringRedactor, type StructuredError, type StructuredErrorInput, type TokenUsage, type ToolCallEvent, TraceContext, createStringRedactor, createStructuredError, defineAuditCatalog, defineDrain, defineEnricher, defineErrorCatalog, defineHttpDrain, estimateLLMCost, flattenToAttributes, flush, formatDuration, genAiMetricViews, getCatalogCode, getEventQueue, getOperationContext, getRequestLogger, getStructuredErrorAttributes, isCatalogError, llmHistogramAdvice, recordLLMCost, recordPromptSent, recordResponseReceived, recordRetry, recordStreamFirstToken, recordStructuredError, recordToolCall, runInOperationContext, runWithRequestContext, shutdown, structuredErrorToJSON, toAttributeValue, trace, track };
+declare function recordLLMCost(ctx: Pick<TraceContext$1, 'setAttribute'>, model: string, usage: TokenUsage, options?: EstimateCostOptions): number | undefined;
+//#endregion
+export { AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AdaptiveSampler, AlwaysSampler, type AttributeGuardrails, type AttributePolicy, AttributeRedactingProcessor, type AttributeRedactingProcessorOptions, type AttributeRedactorConfig, type AttributeRedactorFn, type AttributeRedactorPreset, type AttributeValue, type Attributes, type AuditAction, type AuditCatalog, type AuditCatalogEntry, type AuditDescriptor, type AuditSeverity, type AutotelConfig, type Baggage, type BaggageEntry, type BaggageError, type BaggageFieldDefinition, type BaggageFieldType, BaggageSpanProcessor, type BaggageSpanProcessorOptions, type BuiltinPatternName, BusinessBaggage, type BusinessBaggageValues, CORRELATION_ID_BAGGAGE_KEY, type ClientAttrs, type CloudAttrs, type CodeAttrs, type ConsumerConfig, type ConsumerContext, type ContainerAttrs, type Context, type DBAttrs, type DBConfig, type DefineEventOptions, type DefinedEvent, type DeploymentAttrs, type DeviceAttrs, type DrainOptions, type DrainPipelineOptions, type EnrichContext, type EnricherDefinition, type EnricherOptions, type ErrorAttrs, type ErrorBuildOptions, type ErrorBuilder, type ErrorCatalog, type ErrorCatalogEntry, type EstimateCostOptions, Event, type EventAttributes, type EventSubscriber, type EventsOptions, type Exception, type ExceptionAttrs, type FaaSAttrs, type FeatureFlagAttrs, FilteringSpanProcessor, type FilteringSpanProcessorOptions, type ForkLifecycle, type ForkOptions, type FunnelStatus, GEN_AI_COST_ATTRIBUTE, GEN_AI_COST_USD_BUCKETS, GEN_AI_DURATION_BUCKETS_SECONDS, GEN_AI_TOKEN_USAGE_BUCKETS, type GenAIAttrs, type GraphQLAttrs, HTTPAttributes, type HTTPClientAttrs, type HTTPConfig, type HTTPServerAttrs, type HrTime, type HttpDrainOptions, type HttpDrainRequest, type InstrumentOptions, type K8sAttrs, type LLMConfig, type LagMetricsConfig, type Link, MODEL_PRICING, type MaskFn, type MessagingAttrs, type MessagingConfig, type MessagingOperation, type MessagingSystem, Metric, type MetricsOptions, type ModelPricing, NORMALIZER_PATTERNS, NORMALIZER_PRESETS, type NetworkAttrs, NeverSampler, type OTelAttrs, type OperationContext, type TraceContext as OtelTraceContext, type OutcomeStatus, type ParsedError, type PeerAttrs, type PipelineDrainFn, type ProcessAttrs, type ProducerConfig, type ProducerContext, type PromptSentEvent, REDACTOR_PATTERNS, REDACTOR_PRESETS, ROOT_CONTEXT, type RPCAttrs, RandomSampler, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, type ResponseReceivedEvent, type RetryEvent, type SafeBaggageOptions, type SafeBaggageSchema, type Sampler, type SamplingContext, type SamplingPreset, type SchemaLike, type ServerAddressAttrs, ServiceAttributes, type ServiceAttrs, type SessionAttrs, type Span, type SpanAttributes, type SpanContext, type SpanFilterPredicate, SpanKind, type SpanLink, type SpanNameNormalizerConfig, type SpanNameNormalizerFn, type SpanNameNormalizerPreset, SpanNameNormalizingProcessor, type SpanNameNormalizingProcessorOptions, type SpanOptions, SpanStatusCode, type StepConfig, type StepContext, type StepStatus, type StreamFirstTokenEvent, type StringRedactor, type StructuredError, type StructuredErrorInput, type TLSAttrs, type TextMapGetter, type TextMapSetter, type ThreadAttrs, type TimeInput, type TokenUsage, type ToolCallEvent, type TraceContext$1 as TraceContext, type TraceFlags, type TraceState, type Tracer, type TracerProvider, URLAttributes, type URLAttrs, type UserAttrs, UserIdSampler, type ValuePatternConfig, type WithBaggageOptions, type WithNewContextOptions, type WorkflowConfig, type WorkflowContext, type WorkflowStatus, attrs, autoRedactPII, builtinPatterns, context, createAttributeRedactor, createCounter, createDeterministicTraceId, createDrainPipeline, createHistogram, createLinkFromHeaders, createNoopRequestLogger, createObservableGauge, createRedactedSpan, createSafeBaggageSchema, createStringRedactor, createStructuredError, createUpDownCounter, ctx, dbClient, defineAuditCatalog, defineBaggageSchema, defineDrain, defineEnricher, defineErrorCatalog, defineEvent, defineHttpDrain, enrichWithTraceContext, estimateLLMCost, extractLinksFromBatch, finalizeSpan, flattenMetadata, flattenToAttributes, flush, formatDuration, genAiMetricViews, generateCorrelationId, getActiveContext, getActiveSpan, getAutotelTracer, getAutotelTracerProvider, getCatalogCode, getCorrelationId, getCurrentWorkflowContext, getEventQueue, getEvents, getMeter, getMetrics, getOperationContext, getOrCreateCorrelationId, getRequestLogger, getRequestLoggerSafe, getStructuredErrorAttributes, getTraceContext, getTracer, hasRequestContext, httpClient, httpRequestHeaderAttribute, httpResponseHeaderAttribute, httpServer, identify, init, instrument, isCatalogError, isInWorkflow, isInitialized, isLoggerLocked, isTracing, llmHistogramAdvice, lockLogger, markAsImmediate, mergeAttrs, mergeServiceResource, normalizeAttributeRedactorConfig, otelTrace, parseError, propagation, recordLLMCost, recordPromptSent, recordResponseReceived, recordRetry, recordStreamFirstToken, recordStructuredError, recordToolCall, request, resetEvents, resetMetrics, resolveSamplingPreset, resolveTraceUrl, runInOperationContext, runWithCorrelationId, runWithRequestContext, runWithSpan, safeSetAttributes, samplingPresets, setAutotelTracerProvider, setCorrelationId, setCorrelationIdInBaggage, setDevice, setError, setException, setSession, setUser, shutdown, span, structuredErrorToJSON, toAttributeValue, trace, traceConsumer, traceDB, traceHTTP, traceLLM, traceMessaging, traceProducer, traceStep, traceWorkflow, track, validateAttribute, withBaggage, withNewContext, withTracing };
+//# sourceMappingURL=index.d.ts.map