{"version":3,"sources":["../src/rate-limiter.ts","../src/event-queue.ts","../src/track.ts","../src/variable-name-inference.ts","../src/functional.ts"],"names":["getConfig","getLogger","getOrCreateCorrelationId","span","getEventsConfig","isInitialized","warnIfNotInitialized","getValidationConfig","validateEvent","trace","fileURLToPath","readFileSync","ctx","otelTrace","createTraceContext","AlwaysSampler","wrappedFunction","getSdk","runInOperationContext","setSpanName","context","getContextStorage","SpanStatusCode","getActiveContextWithBaggage","result","propagation"],"mappings":"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","file":"chunk-7ZYUFMWU.cjs","sourcesContent":["/**\n * Token bucket rate limiter for event subscribers\n *\n * Prevents overwhelming downstream events platforms with too many events.\n * Uses token bucket algorithm for smooth rate limiting with burst capacity.\n */\n\nexport interface RateLimiterConfig {\n  /** Maximum events per second (default: 100) */\n  maxEventsPerSecond: number;\n  /** Burst capacity - max events in a single burst (default: 2x rate) */\n  burstCapacity?: number;\n}\n\n/**\n * Token bucket rate limiter\n *\n * Allows bursts up to burstCapacity, then smooths to maxEventsPerSecond.\n * Thread-safe for async operations.\n */\nexport class TokenBucketRateLimiter {\n  private tokens: number;\n  private readonly maxTokens: number;\n  private readonly refillRate: number; // tokens per millisecond\n  private lastRefill: number;\n\n  constructor(config: RateLimiterConfig) {\n    this.maxTokens = config.burstCapacity || config.maxEventsPerSecond * 2;\n    this.tokens = this.maxTokens; // Start with full bucket\n    this.refillRate = config.maxEventsPerSecond / 1000; // Convert to per-ms\n    this.lastRefill = Date.now();\n  }\n\n  /**\n   * Try to consume a token (allow an event)\n   * Returns true if allowed, false if rate limit exceeded\n   */\n  tryConsume(count = 1): boolean {\n    this.refill();\n\n    if (this.tokens >= count) {\n      this.tokens -= count;\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Wait until a token is available (async rate limiting)\n   * Returns a promise that resolves when the event can be processed\n   */\n  async waitForToken(count = 1): Promise<void> {\n    this.refill();\n\n    if (this.tokens >= count) {\n      this.tokens -= count;\n      return;\n    }\n\n    // Calculate wait time until we have enough tokens\n    const tokensNeeded = count - this.tokens;\n    const waitMs = Math.ceil(tokensNeeded / this.refillRate);\n\n    await new Promise((resolve) => setTimeout(resolve, waitMs));\n\n    // After waiting, try again (recursive)\n    return this.waitForToken(count);\n  }\n\n  /**\n   * Refill tokens based on elapsed time\n   */\n  private refill(): void {\n    const now = Date.now();\n    const elapsed = now - this.lastRefill;\n    const tokensToAdd = elapsed * this.refillRate;\n\n    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);\n    this.lastRefill = now;\n  }\n\n  /**\n   * Get current available tokens (for testing/debugging)\n   */\n  getAvailableTokens(): number {\n    this.refill();\n    return Math.floor(this.tokens);\n  }\n\n  /**\n   * Reset the rate limiter (for testing)\n   */\n  reset(): void {\n    this.tokens = this.maxTokens;\n    this.lastRefill = Date.now();\n  }\n}\n","/**\n * Events event queue with batching, backpressure, retry logic, rate limiting, and OTel metrics\n *\n * Exposes delivery pipeline metrics for observability:\n * - autotel.event_delivery.queue.size - Current queue size\n * - autotel.event_delivery.queue.oldest_age_ms - Age of oldest event in queue\n * - autotel.event_delivery.queue.delivered - Successfully delivered events\n * - autotel.event_delivery.queue.failed - Failed event deliveries\n * - autotel.event_delivery.queue.dropped - Dropped events with reason\n * - autotel.event_delivery.queue.latency_ms - Delivery latency histogram\n * - autotel.event_delivery.subscriber.health - Subscriber health (1=healthy, 0=unhealthy)\n */\n\nimport type {\n  Counter,\n  Histogram,\n  ObservableGauge,\n  Attributes,\n} from '@opentelemetry/api';\nimport type { ObservableResult } from '@opentelemetry/api';\nimport type {\n  EventSubscriber,\n  EventAttributes,\n  AutotelEventContext,\n} from './event-subscriber';\nimport { getLogger } from './init';\nimport { getConfig as getRuntimeConfig } from './config';\nimport { TokenBucketRateLimiter, type RateLimiterConfig } from './rate-limiter';\nimport { getOrCreateCorrelationId } from './correlation-id';\n\nexport interface EventData {\n  name: string;\n  attributes?: EventAttributes;\n  timestamp: number;\n  /** Internal: correlation ID for debug breadcrumbs */\n  _correlationId?: string;\n  /** Internal: trace ID for debug breadcrumbs */\n  _traceId?: string;\n  /** Autotel context for trace correlation (passed to subscribers) */\n  autotel?: AutotelEventContext;\n}\n\n/**\n * Drop reasons for event delivery queue metrics\n * LOW CARDINALITY: Only these 4 values allowed in metric labels\n */\nexport type EventDropReason =\n  | 'rate_limit'\n  | 'circuit_open'\n  | 'payload_invalid'\n  | 'shutdown';\n\nexport interface QueueConfig {\n  maxSize: number; // Max events in queue (default: 50,000)\n  batchSize: number; // Events per batch (default: 100)\n  flushInterval: number; // Flush interval in ms (default: 10,000)\n  maxRetries: number; // Max retry attempts (default: 3)\n  rateLimit?: RateLimiterConfig; // Optional rate limiting (default: 100 events/sec)\n}\n\nconst DEFAULT_CONFIG: QueueConfig = {\n  maxSize: 50_000,\n  batchSize: 100,\n  flushInterval: 10_000,\n  maxRetries: 3,\n  rateLimit: {\n    maxEventsPerSecond: 100,\n    burstCapacity: 200,\n  },\n};\n\n/**\n * Metrics for event delivery queue observability\n *\n * All metrics use low-cardinality labels only:\n * - subscriber: stable identifier (e.g., 'posthog', 'mixpanel')\n * - reason: one of EventDropReason values\n */\ninterface EventQueueMetrics {\n  /** Current queue size (observable gauge) */\n  queueSize: ObservableGauge;\n  /** Age of oldest event in queue in ms (observable gauge) */\n  oldestAge: ObservableGauge;\n  /** Successfully delivered events (counter) */\n  delivered: Counter;\n  /** Failed event deliveries after all retries (counter) */\n  failed: Counter;\n  /** Dropped events (counter with reason label) */\n  dropped: Counter;\n  /** Event delivery latency histogram in ms */\n  latency: Histogram;\n  /** Subscriber health: 1=healthy, 0=unhealthy (observable gauge) */\n  subscriberHealth: ObservableGauge;\n}\n\n/**\n * Get subscriber name for metrics (stable, low-cardinality)\n *\n * Priority:\n * 1. Explicit config: subscriber.name\n * 2. Class static property (if available)\n * 3. Fallback: lowercase class name without \"Subscriber\" suffix\n */\nfunction getSubscriberName(subscriber: EventSubscriber): string {\n  // Use explicit name if provided\n  if (subscriber.name) {\n    return subscriber.name.toLowerCase();\n  }\n\n  // Fallback: derive from class name\n  const className = subscriber.constructor?.name || 'unknown';\n  return className.replace(/Subscriber$/i, '').toLowerCase();\n}\n\n/**\n * Events queue with batching and backpressure\n *\n * Features:\n * - Batches events for efficient sending\n * - Bounded queue with drop-oldest policy (prod) or blocking (dev)\n * - Exponential backoff retry\n * - Rate limiting to prevent overwhelming subscribers\n * - Graceful flush on shutdown\n */\nexport class EventQueue {\n  private queue: EventData[] = [];\n  private flushTimer: NodeJS.Timeout | null = null;\n  private readonly config: QueueConfig;\n  private readonly subscribers: EventSubscriber[];\n  private readonly rateLimiter: TokenBucketRateLimiter | null;\n  private flushPromise: Promise<void> | null = null;\n  private isShuttingDown = false;\n\n  // Metrics\n  private metrics: EventQueueMetrics | null = null;\n\n  // Observable callback cleanup functions\n  private observableCleanups: Array<() => void> = [];\n\n  // Subscriber health tracking (for observable gauges)\n  private subscriberHealthy: Map<string, boolean> = new Map();\n\n  constructor(subscribers: EventSubscriber[], config?: Partial<QueueConfig>) {\n    this.subscribers = subscribers;\n    this.config = { ...DEFAULT_CONFIG, ...config };\n\n    // Initialize rate limiter if configured\n    this.rateLimiter = this.config.rateLimit\n      ? new TokenBucketRateLimiter(this.config.rateLimit)\n      : null;\n\n    // Initialize subscriber health tracking\n    for (const subscriber of subscribers) {\n      const name = getSubscriberName(subscriber);\n      this.subscriberHealthy.set(name, true);\n    }\n\n    // Initialize metrics\n    this.initMetrics();\n  }\n\n  /**\n   * Initialize OTel metrics for queue observability\n   */\n  private initMetrics(): void {\n    const runtimeConfig = getRuntimeConfig();\n    const meter = runtimeConfig.meter;\n\n    // Queue size gauge - observe current queue length\n    const queueSize = meter.createObservableGauge(\n      'autotel.event_delivery.queue.size',\n      {\n        description: 'Current number of events in the delivery queue',\n        unit: 'count',\n      },\n    );\n    const queueSizeCallback = (observableResult: ObservableResult) => {\n      observableResult.observe(this.queue.length);\n    };\n    queueSize.addCallback(queueSizeCallback);\n    this.observableCleanups.push(() =>\n      queueSize.removeCallback(queueSizeCallback),\n    );\n\n    // Oldest event age gauge - observe wait time of oldest event\n    const oldestAge = meter.createObservableGauge(\n      'autotel.event_delivery.queue.oldest_age_ms',\n      {\n        description: 'Age of the oldest event in the queue in milliseconds',\n        unit: 'ms',\n      },\n    );\n    const oldestAgeCallback = (observableResult: ObservableResult) => {\n      if (this.queue.length > 0) {\n        const oldest = this.queue[0]!;\n        const ageMs = Date.now() - oldest.timestamp;\n        observableResult.observe(ageMs);\n      } else {\n        observableResult.observe(0);\n      }\n    };\n    oldestAge.addCallback(oldestAgeCallback);\n    this.observableCleanups.push(() =>\n      oldestAge.removeCallback(oldestAgeCallback),\n    );\n\n    // Delivered counter\n    const delivered = meter.createCounter(\n      'autotel.event_delivery.queue.delivered',\n      {\n        description: 'Number of events successfully delivered to subscribers',\n        unit: 'count',\n      },\n    );\n\n    // Failed counter\n    const failed = meter.createCounter('autotel.event_delivery.queue.failed', {\n      description:\n        'Number of events that failed delivery after all retry attempts',\n      unit: 'count',\n    });\n\n    // Dropped counter (with reason label)\n    const dropped = meter.createCounter(\n      'autotel.event_delivery.queue.dropped',\n      {\n        description: 'Number of events dropped from the queue',\n        unit: 'count',\n      },\n    );\n\n    // Latency histogram\n    const latency = meter.createHistogram(\n      'autotel.event_delivery.queue.latency_ms',\n      {\n        description: 'Event delivery latency from enqueue to successful send',\n        unit: 'ms',\n      },\n    );\n\n    // Subscriber health gauge\n    const subscriberHealth = meter.createObservableGauge(\n      'autotel.event_delivery.subscriber.health',\n      {\n        description: 'Subscriber health status (1=healthy, 0=unhealthy)',\n        unit: '1',\n      },\n    );\n    const subscriberHealthCallback = (observableResult: ObservableResult) => {\n      for (const [subscriberName, isHealthy] of this.subscriberHealthy) {\n        observableResult.observe(isHealthy ? 1 : 0, {\n          subscriber: subscriberName,\n        });\n      }\n    };\n    subscriberHealth.addCallback(subscriberHealthCallback);\n    this.observableCleanups.push(() =>\n      subscriberHealth.removeCallback(subscriberHealthCallback),\n    );\n\n    this.metrics = {\n      queueSize,\n      oldestAge,\n      delivered,\n      failed,\n      dropped,\n      latency,\n      subscriberHealth,\n    };\n  }\n\n  /**\n   * Record a dropped event with reason and emit debug breadcrumb\n   */\n  private recordDropped(\n    reason: EventDropReason,\n    event?: EventData,\n    subscriberName?: string,\n  ): void {\n    // Increment metric\n    const attrs: Attributes = { reason };\n    if (subscriberName) {\n      attrs.subscriber = subscriberName;\n    }\n    this.metrics?.dropped.add(1, attrs);\n\n    // Debug breadcrumb log (rate-limited via existing logger)\n    const logLevel = reason === 'payload_invalid' ? 'error' : 'warn';\n    const logger = getLogger();\n\n    if (logLevel === 'error') {\n      logger.error(\n        {\n          eventName: event?.name,\n          subscriber: subscriberName,\n          reason,\n          correlationId: event?._correlationId,\n          traceId: event?._traceId,\n        },\n        `[autotel] Event dropped: ${reason}`,\n      );\n    } else {\n      logger.warn(\n        {\n          eventName: event?.name,\n          subscriber: subscriberName,\n          reason,\n          correlationId: event?._correlationId,\n          traceId: event?._traceId,\n        },\n        `[autotel] Event dropped: ${reason}`,\n      );\n    }\n  }\n\n  /**\n   * Record permanent delivery failure (after all retries exhausted)\n   * Increments failed counter and logs error\n   */\n  private recordFailed(\n    event: EventData,\n    subscriberName: string,\n    error?: Error,\n  ): void {\n    this.metrics?.failed.add(1, { subscriber: subscriberName });\n\n    // Mark subscriber as unhealthy\n    this.subscriberHealthy.set(subscriberName, false);\n\n    // Debug breadcrumb log\n    getLogger().error(\n      {\n        eventName: event.name,\n        subscriber: subscriberName,\n        correlationId: event._correlationId,\n        traceId: event._traceId,\n        err: error,\n      },\n      `[autotel] Event delivery failed after all retries`,\n    );\n  }\n\n  /**\n   * Mark subscriber as unhealthy on transient failure (without incrementing failed counter)\n   * Used during retry attempts - only recordFailed should increment the counter\n   */\n  private markSubscriberUnhealthy(subscriberName: string): void {\n    this.subscriberHealthy.set(subscriberName, false);\n  }\n\n  /**\n   * Record successful delivery\n   */\n  private recordDelivered(\n    event: EventData,\n    subscriberName: string,\n    startTime: number,\n  ): void {\n    const latencyMs = Date.now() - startTime;\n\n    this.metrics?.delivered.add(1, { subscriber: subscriberName });\n    this.metrics?.latency.record(latencyMs, { subscriber: subscriberName });\n\n    // Mark subscriber as healthy\n    this.subscriberHealthy.set(subscriberName, true);\n  }\n\n  /**\n   * Enqueue an event for sending\n   *\n   * Backpressure policy:\n   * - Drops oldest event and logs warning if queue is full (same behavior in all environments)\n   */\n  enqueue(event: EventData): void {\n    // Reject events during shutdown\n    if (this.isShuttingDown) {\n      this.recordDropped('shutdown', event);\n      return;\n    }\n\n    // Check queue size\n    if (this.queue.length >= this.config.maxSize) {\n      // Drop oldest event and log warning (same behavior in all environments)\n      const droppedEvent = this.queue.shift();\n      this.recordDropped('rate_limit', droppedEvent);\n      getLogger().warn(\n        {\n          droppedEvent: droppedEvent?.name,\n        },\n        `[autotel] Events queue full (${this.config.maxSize} events). ` +\n          'Dropping oldest event. Events are being produced faster than they can be sent. ' +\n          'Check your subscribers or reduce tracking frequency.',\n      );\n    }\n\n    // Enrich event with correlation context for debug breadcrumbs\n    const enrichedEvent: EventData = {\n      ...event,\n      _correlationId: event._correlationId || getOrCreateCorrelationId(),\n    };\n\n    this.queue.push(enrichedEvent);\n    this.scheduleBatchFlush();\n  }\n\n  /**\n   * Schedule a batch flush if not already scheduled\n   */\n  private scheduleBatchFlush(): void {\n    if (this.flushTimer || this.flushPromise) return;\n\n    this.flushTimer = setTimeout(() => {\n      this.flushTimer = null;\n      void this.flushBatch();\n    }, this.config.flushInterval);\n  }\n\n  /**\n   * Flush a batch of events\n   * Uses promise-based concurrency control to prevent race conditions\n   */\n  private async flushBatch(): Promise<void> {\n    if (this.queue.length === 0) return;\n\n    // If already flushing, wait for existing flush\n    if (this.flushPromise) {\n      await this.flushPromise;\n      return;\n    }\n\n    this.flushPromise = this.doFlushBatch();\n\n    try {\n      await this.flushPromise;\n    } finally {\n      this.flushPromise = null;\n\n      // Schedule next flush if more events\n      if (this.queue.length > 0) {\n        this.scheduleBatchFlush();\n      }\n    }\n  }\n\n  /**\n   * Internal flush implementation\n   */\n  private async doFlushBatch(): Promise<void> {\n    const batch = this.queue.splice(0, this.config.batchSize);\n    await this.sendWithRetry(batch, this.config.maxRetries);\n  }\n\n  /**\n   * Send events with exponential backoff retry\n   * Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.\n   * On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.\n   */\n  private async sendWithRetry(\n    events: EventData[],\n    retriesLeft: number,\n    subscribersByEventIndex?: Map<number, Set<string>>,\n  ): Promise<void> {\n    const failedDeliveries = await this.sendToSubscribers(\n      events,\n      subscribersByEventIndex,\n    );\n\n    if (failedDeliveries.length > 0) {\n      if (retriesLeft > 0) {\n        // Retry only events that had at least one failure, and only to subscribers that failed (avoid re-sending to healthy subscribers and double-counting delivered)\n        const failedEventIndices = new Set(\n          failedDeliveries.map((f) => f.eventIndex),\n        );\n        const failedEventIndicesOrdered = [...failedEventIndices].sort(\n          (a, b) => a - b,\n        );\n        const eventsToRetry = failedEventIndicesOrdered.map(\n          (i) => events[i],\n        ) as EventData[];\n        const failedSubscribersByRetryIndex = new Map<number, Set<string>>();\n        for (let j = 0; j < failedEventIndicesOrdered.length; j++) {\n          const origIndex = failedEventIndicesOrdered[j];\n          const set = new Set<string>();\n          for (const { eventIndex, subscriberName } of failedDeliveries) {\n            if (eventIndex === origIndex) set.add(subscriberName);\n          }\n          failedSubscribersByRetryIndex.set(j, set);\n        }\n        const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1000;\n        await new Promise((resolve) => setTimeout(resolve, delay));\n        return this.sendWithRetry(\n          eventsToRetry,\n          retriesLeft - 1,\n          failedSubscribersByRetryIndex,\n        );\n      } else {\n        // Give up after max retries - record one failure per (event, subscriber) pair\n        for (const { eventIndex, subscriberName, error } of failedDeliveries) {\n          const event = events[eventIndex];\n          if (event) this.recordFailed(event, subscriberName, error);\n        }\n\n        const failedSubscriberNames = [\n          ...new Set(failedDeliveries.map((f) => f.subscriberName)),\n        ];\n        getLogger().error(\n          {\n            failedSubscribers: failedSubscriberNames,\n            retriesAttempted: this.config.maxRetries,\n          },\n          '[autotel] Failed to send events after retries',\n        );\n      }\n    }\n  }\n\n  /**\n   * Send events to configured subscribers with rate limiting and metrics.\n   * When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.\n   * Returns per-event, per-subscriber failures (empty if all succeeded).\n   */\n  private async sendToSubscribers(\n    events: EventData[],\n    subscribersByEventIndex?: Map<number, Set<string>>,\n  ): Promise<\n    Array<{ eventIndex: number; subscriberName: string; error?: Error }>\n  > {\n    const failedDeliveries: Array<{\n      eventIndex: number;\n      subscriberName: string;\n      error?: Error;\n    }> = [];\n\n    const sendOne = async (event: EventData, eventIndex: number) => {\n      // On retry, only try subscribers that failed for this event (never re-send to healthy subscribers)\n      const subscriberNames = subscribersByEventIndex?.get(eventIndex);\n      const failures = await this.sendEventToSubscribers(\n        event,\n        subscriberNames ?? undefined,\n      );\n      for (const failure of failures) {\n        failedDeliveries.push({\n          eventIndex,\n          subscriberName: failure.subscriberName,\n          error: failure.error,\n        });\n      }\n    };\n\n    if (!this.rateLimiter) {\n      for (let i = 0; i < events.length; i++) {\n        const event = events[i];\n        if (event) await sendOne(event, i);\n      }\n      return failedDeliveries;\n    }\n\n    for (let i = 0; i < events.length; i++) {\n      await this.rateLimiter.waitForToken();\n      const event = events[i];\n      if (event) await sendOne(event, i);\n    }\n\n    return failedDeliveries;\n  }\n\n  /**\n   * Send a single event to subscribers.\n   * - When subscriberNames is undefined (initial attempt): send to all subscribers.\n   * - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).\n   * Returns list of subscribers that failed (empty if all succeeded).\n   */\n  private async sendEventToSubscribers(\n    event: EventData,\n    subscriberNames?: Set<string>,\n  ): Promise<Array<{ subscriberName: string; error?: Error }>> {\n    const startTime = event.timestamp;\n    const failures: Array<{ subscriberName: string; error?: Error }> = [];\n\n    const subscribersToTry =\n      subscriberNames === undefined\n        ? this.subscribers\n        : this.subscribers.filter((s) =>\n            subscriberNames.has(getSubscriberName(s)),\n          );\n\n    const results = await Promise.allSettled(\n      subscribersToTry.map(async (subscriber) => {\n        const subscriberName = getSubscriberName(subscriber);\n\n        try {\n          await subscriber.trackEvent(event.name, event.attributes, {\n            autotel: event.autotel,\n          });\n          this.recordDelivered(event, subscriberName, startTime);\n          return { subscriberName, success: true };\n        } catch (error) {\n          this.markSubscriberUnhealthy(subscriberName);\n          return {\n            subscriberName,\n            success: false,\n            error: error instanceof Error ? error : undefined,\n          };\n        }\n      }),\n    );\n\n    for (const result of results) {\n      if (result.status === 'fulfilled' && !result.value.success) {\n        failures.push({\n          subscriberName: result.value.subscriberName,\n          error: result.value.error,\n        });\n      }\n    }\n\n    return failures;\n  }\n\n  /**\n   * Flush all remaining events. Queue remains usable after flush (e.g. for\n   * auto-flush at root span end). Use shutdown() when tearing down the queue.\n   */\n  async flush(): Promise<void> {\n    // Cancel any pending timer\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer);\n      this.flushTimer = null;\n    }\n\n    // Wait for any in-progress flush to complete\n    if (this.flushPromise) {\n      await this.flushPromise;\n    }\n\n    // Flush all remaining batches\n    while (this.queue.length > 0) {\n      await this.doFlushBatch();\n    }\n  }\n\n  /**\n   * Flush remaining events and permanently disable the queue (reject new events).\n   * Use for process/SDK shutdown; use flush() for periodic or span-end drain.\n   */\n  async shutdown(): Promise<void> {\n    this.isShuttingDown = true;\n    await this.flush();\n  }\n\n  /**\n   * Cleanup observable metric callbacks to prevent memory leaks\n   * Call this when destroying the EventQueue instance\n   */\n  cleanup(): void {\n    // Remove all observable callbacks\n    for (const cleanupFn of this.observableCleanups) {\n      try {\n        cleanupFn();\n      } catch {\n        // Ignore cleanup errors\n      }\n    }\n    this.observableCleanups = [];\n  }\n\n  /**\n   * Get queue size (for testing/debugging)\n   */\n  size(): number {\n    return this.queue.length;\n  }\n\n  /**\n   * Get subscriber health status (for testing/debugging)\n   */\n  getSubscriberHealth(): Map<string, boolean> {\n    return new Map(this.subscriberHealthy);\n  }\n\n  /**\n   * Check if a specific subscriber is healthy\n   */\n  isSubscriberHealthy(subscriberName: string): boolean {\n    return this.subscriberHealthy.get(subscriberName.toLowerCase()) ?? true;\n  }\n\n  /**\n   * Manually mark a subscriber as healthy or unhealthy\n   * (used for circuit breaker integration)\n   */\n  setSubscriberHealth(subscriberName: string, healthy: boolean): void {\n    this.subscriberHealthy.set(subscriberName.toLowerCase(), healthy);\n  }\n}\n","/**\n * Global track() function for business events\n *\n * Simple, no instantiation needed, auto-attaches trace context\n */\n\nimport { trace } from '@opentelemetry/api';\nimport { EventQueue } from './event-queue';\nimport {\n  getConfig,\n  warnIfNotInitialized,\n  isInitialized,\n  getValidationConfig,\n  getEventsConfig,\n} from './init';\nimport { validateEvent } from './validation';\nimport { getOrCreateCorrelationId } from './correlation-id';\nimport type { AutotelEventContext } from './event-subscriber';\n\n// Global events queue (initialized on first track call)\nlet eventsQueue: EventQueue | null = null;\n\n/**\n * Build autotel event context for trace correlation\n *\n * Works in multiple contexts:\n * 1. Inside a span → use current span's trace_id + span_id\n * 2. Outside span → use correlation_id only\n * 3. With trace URL config → include clickable trace URL\n */\nfunction buildAutotelContext(\n  span: ReturnType<typeof trace.getActiveSpan>,\n): AutotelEventContext | undefined {\n  const eventsConfig = getEventsConfig();\n  const config = getConfig();\n\n  // Always generate a correlation_id\n  const correlationId = getOrCreateCorrelationId();\n\n  // Return minimal context if trace context is not enabled\n  if (!eventsConfig?.includeTraceContext) {\n    return {\n      correlation_id: correlationId,\n    };\n  }\n\n  // Build base context\n  const autotelContext: AutotelEventContext = {\n    correlation_id: correlationId,\n  };\n\n  // Add trace context if inside a span\n  const spanContext = span?.spanContext();\n  if (spanContext) {\n    autotelContext.trace_id = spanContext.traceId;\n    autotelContext.span_id = spanContext.spanId;\n\n    // Trace flags as 2-char hex string (canonical format)\n    autotelContext.trace_flags = spanContext.traceFlags\n      .toString(16)\n      .padStart(2, '0');\n\n    // Tracestate if present\n    // Defensive: serialize() is standard OTel API but may be missing in some runtimes\n    const traceState = spanContext.traceState;\n    if (traceState) {\n      try {\n        if (typeof traceState.serialize === 'function') {\n          const traceStateStr = traceState.serialize();\n          if (traceStateStr) {\n            autotelContext.trace_state = traceStateStr;\n          }\n        }\n      } catch {\n        // Silently ignore serialization errors\n      }\n    }\n\n    // Generate trace URL if configured\n    if (eventsConfig.traceUrl && config) {\n      const traceUrl = eventsConfig.traceUrl({\n        traceId: spanContext.traceId,\n        spanId: spanContext.spanId,\n        correlationId,\n        serviceName: config.service,\n        environment: config.environment,\n      });\n      if (traceUrl) {\n        autotelContext.trace_url = traceUrl;\n      }\n    }\n  } else {\n    // Outside span but may still have trace URL generator\n    if (eventsConfig.traceUrl && config) {\n      const traceUrl = eventsConfig.traceUrl({\n        correlationId,\n        serviceName: config.service,\n        environment: config.environment,\n      });\n      if (traceUrl) {\n        autotelContext.trace_url = traceUrl;\n      }\n    }\n  }\n\n  return autotelContext;\n}\n\n/**\n * Initialize events queue lazily\n */\nfunction getOrCreateQueue(): EventQueue | null {\n  if (!isInitialized()) {\n    warnIfNotInitialized('track()');\n    return null;\n  }\n\n  if (!eventsQueue) {\n    const config = getConfig();\n    if (!config?.subscribers || config.subscribers.length === 0) {\n      // No subscribers configured - no-op\n      return null;\n    }\n\n    eventsQueue = new EventQueue(config.subscribers);\n  }\n\n  return eventsQueue;\n}\n\n/**\n * Track a business events event\n *\n * Features:\n * - Auto-attaches traceId and spanId if in active span\n * - Batched sending with retry\n * - Type-safe with optional generic\n * - No-op if init() not called or no subscribers configured\n *\n * @example Basic usage\n * ```typescript\n * track('user.signup', { userId: '123', plan: 'pro' })\n * ```\n *\n * @example With type safety\n * ```typescript\n * interface EventDatas {\n *   'user.signup': { userId: string; plan: string }\n *   'plan.upgraded': { userId: string; revenue: number }\n * }\n *\n * track<EventDatas>('user.signup', { userId: '123', plan: 'pro' })\n * ```\n *\n * @example Trace correlation (automatic)\n * ```typescript\n * @Instrumented()\n * class UserService {\n *   async createUser(data: CreateUserData) {\n *     // This track call automatically includes traceId + spanId\n *     track('user.signup', { userId: data.id })\n *   }\n * }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function track<Events extends Record<string, any> = Record<string, any>>(\n  event: keyof Events & string,\n  data?: Events[typeof event],\n): void {\n  const queue = getOrCreateQueue();\n  if (!queue) return; // No-op if not initialized or no subscribers\n\n  // Validate and sanitize input (with custom config if provided)\n  const validationConfig = getValidationConfig();\n  const validated = validateEvent(event, data, validationConfig || undefined);\n\n  // Auto-attach trace context if available (free win!)\n  const span = trace.getActiveSpan();\n  const enrichedData = span\n    ? {\n        ...validated.attributes,\n        traceId: span.spanContext().traceId,\n        spanId: span.spanContext().spanId,\n      }\n    : validated.attributes;\n\n  // Build autotel context (same as Event class)\n  const autotelContext = buildAutotelContext(span);\n\n  queue.enqueue({\n    name: validated.eventName,\n    attributes: enrichedData,\n    timestamp: Date.now(),\n    autotel: autotelContext,\n  });\n}\n\n/**\n * Get events queue (for flush/shutdown)\n * @internal\n */\nexport function getEventQueue(): EventQueue | null {\n  return eventsQueue;\n}\n\n/**\n * Reset events queue (for shutdown/cleanup)\n * @internal\n */\nexport function resetEventQueue(): void {\n  eventsQueue = null;\n}\n","/**\n * Variable Name Inference Utility\n *\n * Attempts to infer variable names from const/export const assignments\n * by analyzing the call stack and parsing source code.\n *\n * This is a best-effort approach with graceful degradation - if inference\n * fails for any reason, it returns undefined without breaking the application.\n */\n\nimport { readFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\n\ninterface CallLocation {\n  file: string;\n  line: number;\n  column: number;\n}\n\n/**\n * LRU Cache for inferred variable names\n * Key: \"file:line\" (e.g., \"/path/to/file.ts:42\")\n * Value: inferred variable name or undefined\n */\nconst inferenceCache = new Map<string, string | undefined>();\nconst MAX_CACHE_SIZE = 50;\n\n/**\n * Captures the current call stack\n */\nfunction captureStackTrace(): string {\n  const originalStackTraceLimit = Error.stackTraceLimit;\n  Error.stackTraceLimit = 10; // Only need first few frames\n\n  const err = new Error('Stack trace capture');\n  const stack = err.stack || '';\n\n  Error.stackTraceLimit = originalStackTraceLimit;\n  return stack;\n}\n\n/**\n * Parses the stack trace to find where trace() was called\n *\n * Stack trace format (Node.js):\n *   at functionName (file:line:column)\n *   at file:line:column\n *\n * We skip frames until we find one that's NOT in functional.ts or this file.\n * We also need to skip one additional frame (the trace/span/instrument function itself)\n * to get to the actual user code.\n */\nfunction parseCallLocation(stack: string): CallLocation | undefined {\n  const lines = stack.split('\\n');\n  let skippedExternalFrame = false;\n\n  for (const line of lines) {\n    // Skip if line contains this file or functional.ts (internal frames)\n    // Be specific about the filename to avoid matching test files\n    if (\n      line.includes('variable-name-inference.ts') ||\n      line.includes('variable-name-inference.js') ||\n      line.includes('functional.ts') ||\n      line.includes('functional.js')\n    ) {\n      continue;\n    }\n\n    // Match various stack trace formats\n    // Format 1: at functionName (file:line:column)\n    // Format 2: at file:line:column\n    const match =\n      line.match(/at\\s+(?:.*\\s+)?\\(?([^:]+):(\\d+):(\\d+)\\)?/) ||\n      line.match(/^.*?([^:]+):(\\d+):(\\d+)/);\n\n    if (match) {\n      let filePath = match[1]!.trim();\n\n      // Handle file:// URLs (convert to paths)\n      if (filePath.startsWith('file://')) {\n        try {\n          filePath = fileURLToPath(filePath);\n        } catch {\n          continue;\n        }\n      }\n\n      // Skip the first external frame (the trace/span function itself)\n      // We want the frame where the user CALLS trace(), not inside trace()\n      if (!skippedExternalFrame) {\n        skippedExternalFrame = true;\n        continue;\n      }\n\n      return {\n        file: filePath,\n        line: Number.parseInt(match[2]!, 10),\n        column: Number.parseInt(match[3]!, 10),\n      };\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Reads a specific line from a source file\n */\nfunction readSourceLine(\n  filePath: string,\n  lineNumber: number,\n): string | undefined {\n  try {\n    // Check if we can access the file system (not available in edge runtimes)\n    if (typeof readFileSync !== 'function') {\n      return undefined;\n    }\n\n    const content = readFileSync(filePath, 'utf8');\n    const lines = content.split('\\n');\n\n    // Line numbers are 1-based\n    return lines[lineNumber - 1];\n  } catch {\n    // File doesn't exist, permission denied, or other error\n    return undefined;\n  }\n}\n\n/**\n * Extracts variable name from source code line using regex patterns\n *\n * Supported patterns:\n * - const varName = anyFunction(\n * - export const varName = anyFunction(\n * - let varName = anyFunction(\n * - var varName = anyFunction(\n *\n * Note: This won't work with destructuring assignments or complex patterns\n */\nfunction extractVariableName(sourceLine: string): string | undefined {\n  // Remove leading/trailing whitespace\n  const trimmed = sourceLine.trim();\n\n  // Pattern: (export)? (const|let|var) varName = anyFunctionCall(\n  // We match any function call, not just trace(), to support wrapper functions\n  const patterns = [\n    // export const varName = anyFunction(\n    /export\\s+const\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n    // const varName = anyFunction(\n    /const\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n    // export let varName = anyFunction(\n    /export\\s+let\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n    // let varName = anyFunction(\n    /let\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n    // export var varName = anyFunction(\n    /export\\s+var\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n    // var varName = anyFunction(\n    /var\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*[a-zA-Z_$][a-zA-Z0-9_$]*\\s*\\(/,\n  ];\n\n  for (const pattern of patterns) {\n    const match = trimmed.match(pattern);\n    if (match && match[1]) {\n      return match[1];\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Adds an entry to the cache with LRU eviction\n */\nfunction cacheInference(key: string, value: string | undefined): void {\n  // If cache is full, remove oldest entry (first entry in Map)\n  if (inferenceCache.size >= MAX_CACHE_SIZE) {\n    const firstKey = inferenceCache.keys().next().value;\n    if (firstKey) {\n      inferenceCache.delete(firstKey);\n    }\n  }\n\n  inferenceCache.set(key, value);\n}\n\n/**\n * Main entry point: Attempts to infer the variable name from the call stack\n *\n * This function:\n * 1. Captures the call stack\n * 2. Parses it to find where trace() was called (file + line)\n * 3. Reads that line from the source file\n * 4. Extracts the variable name using regex\n *\n * Returns undefined if inference fails at any step (graceful degradation).\n * Results are cached to avoid repeated file I/O.\n *\n * @returns The inferred variable name, or undefined if inference failed\n */\nexport function inferVariableNameFromCallStack(): string | undefined {\n  try {\n    // Capture stack trace\n    const stack = captureStackTrace();\n\n    // Parse stack to find trace() call location\n    const callLocation = parseCallLocation(stack);\n    if (!callLocation) {\n      return undefined;\n    }\n\n    // Check cache\n    const cacheKey = `${callLocation.file}:${callLocation.line}`;\n    if (inferenceCache.has(cacheKey)) {\n      return inferenceCache.get(cacheKey);\n    }\n\n    // Read source line\n    const sourceLine = readSourceLine(callLocation.file, callLocation.line);\n    if (!sourceLine) {\n      return undefined;\n    }\n\n    // Extract variable name\n    const variableName = extractVariableName(sourceLine);\n\n    // Cache result (even if undefined, to avoid repeated failed attempts)\n    cacheInference(cacheKey, variableName);\n\n    return variableName;\n  } catch {\n    // Graceful degradation - don't break the app if inference fails\n    return undefined;\n  }\n}\n\n/**\n * Clears the inference cache (useful for testing)\n */\nexport function clearInferenceCache(): void {\n  inferenceCache.clear();\n}\n","/**\n * Functional API for non-class code\n *\n * Three approaches for different use cases:\n * 1. trace() - Zero-ceremony HOF for single functions\n * 2. withTracing() - Middleware-style composable wrapper\n * 3. instrument() - Batch auto-instrumentation for modules\n *\n * @example trace() - Single function\n * ```typescript\n * export const createUser = trace(ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * ```\n *\n * @example withTracing() - Composable middleware\n * ```typescript\n * export const createUser = withTracing({\n *   name: 'user.create'\n * })(ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * ```\n *\n * @example instrument() - Batch instrumentation\n * ```typescript\n * export default instrument({\n *   createUser: async (data) => { },\n *   updateUser: async (id, data) => { }\n * }, { serviceName: 'user' })\n * ```\n */\n\nimport {\n  SpanStatusCode,\n  trace as otelTrace,\n  context,\n  propagation,\n  type Span,\n} from '@opentelemetry/api';\nimport { getConfig } from './config';\nimport { getConfig as getInitConfig, getSdk } from './init';\nimport { type Sampler, type SamplingContext, AlwaysSampler } from './sampling';\nimport { getEventQueue } from './track';\nimport type { TraceContext } from './trace-context';\nimport {\n  createTraceContext,\n  getActiveContextWithBaggage,\n  getContextStorage,\n} from './trace-context';\nimport { setSpanName } from './trace-helpers';\nimport { runInOperationContext } from './operation-context';\nimport { inferVariableNameFromCallStack } from './variable-name-inference';\n\n/**\n * Complete trace context containing trace identifiers and span methods\n *\n * The ctx parameter in trace() functions provides:\n * - traceId, spanId, correlationId from the active span\n * - Span manipulation methods (setAttribute, setAttributes, setStatus, recordException)\n *\n * For custom context, access it directly in your functions (standard OpenTelemetry pattern).\n *\n * @example\n * ```typescript\n * import { trace } from 'autotel'\n *\n * export const createUser = trace(ctx => async (data: CreateUserData) => {\n *   // Get custom context directly (standard OTel approach)\n *   const userId = getCurrentUserId()\n *   const tenantId = getCurrentTenant()\n *\n *   // Use ctx for span operations and trace IDs\n *   ctx.setAttribute('user.id', data.id)\n *   ctx.setAttribute('user.tenant', tenantId)\n *   console.log(ctx.traceId)  // Trace IDs available\n * })\n * ```\n */\nexport type { TraceContext } from './trace-context';\n\n/**\n * Helper type to extract function signature from factory pattern\n * This helps TypeScript infer types correctly for factory functions\n */\ntype ExtractFunctionSignature<T> = T extends (ctx: TraceContext) => infer F\n  ? F extends (...args: infer Args) => infer Return\n    ? (...args: Args) => Return\n    : never\n  : never;\n\n/**\n * Helper type to exclude functions that return functions from immediate execution overloads\n */\ntype ExcludeFactoryReturn<T> = T extends (ctx: TraceContext) => infer F\n  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    F extends (...args: any[]) => any\n    ? never\n    : T\n  : T;\n\ntype GenericFunction = (...args: unknown[]) => unknown;\n\nconst FACTORY_NAME_HINTS = new Set([\n  'ctx',\n  '_ctx',\n  'context',\n  'tracecontext',\n  'tracectx',\n]);\nconst TRACE_FACTORY_SET = new WeakSet<object>();\n\nconst SINGLE_LINE_COMMENT_REGEX = /\\/\\/.*$/gm;\nconst MULTI_LINE_COMMENT_REGEX = /\\/\\*[\\s\\S]*?\\*\\//gm;\nconst PARAM_TOKEN_SANITIZE_REGEX = new RegExp(String.raw`[{}\\[\\]\\s]`, 'g');\n\nfunction markAsTraceFactory(fn: object): void {\n  TRACE_FACTORY_SET.add(fn);\n}\n\nfunction hasFactoryMark(fn: object): boolean {\n  return TRACE_FACTORY_SET.has(fn);\n}\n\nfunction sanitizeParameterToken(token: string): string {\n  const [firstToken] = token.split('=');\n  return (firstToken ?? '').replaceAll(PARAM_TOKEN_SANITIZE_REGEX, '').trim();\n}\n\nfunction getFirstParameterToken(fn: GenericFunction): string | null {\n  let source = Function.prototype.toString.call(fn);\n  source = source\n    .replaceAll(MULTI_LINE_COMMENT_REGEX, '')\n    .replaceAll(SINGLE_LINE_COMMENT_REGEX, '')\n    .trim();\n\n  // Arrow functions\n  const arrowMatch = source.match(\n    /^(?:async\\s*)?(?:\\(([^)]*)\\)|([^=()]+))\\s*=>/,\n  );\n  if (arrowMatch) {\n    const params = (arrowMatch[1] ?? arrowMatch[2] ?? '').split(',');\n    const first = params[0]?.trim();\n    if (first) {\n      return sanitizeParameterToken(first);\n    }\n    return null;\n  }\n\n  // Function declarations/expressions\n  const functionMatch = source.match(/^[^(]*\\(([^)]*)\\)/);\n  if (functionMatch) {\n    const params = functionMatch[1]?.split(',');\n    const first = params?.[0]?.trim();\n    if (first) {\n      return sanitizeParameterToken(first);\n    }\n  }\n\n  return null;\n}\n\nfunction looksLikeTraceFactory(fn: GenericFunction): boolean {\n  if (hasFactoryMark(fn)) {\n    return true;\n  }\n\n  if (fn.length === 0) {\n    if (!isAsyncFunction(fn)) {\n      try {\n        const result = fn();\n        return typeof result === 'function';\n      } catch {\n        return false;\n      }\n    }\n    return false;\n  }\n\n  const firstParam = getFirstParameterToken(fn);\n  if (!firstParam) {\n    return false;\n  }\n\n  const normalized = firstParam.toLowerCase();\n  if (\n    FACTORY_NAME_HINTS.has(normalized) ||\n    normalized.startsWith('ctx') ||\n    normalized.startsWith('_ctx') ||\n    normalized.startsWith('trace') ||\n    normalized.endsWith('ctx') || // Match baseCtx, spanCtx, etc.\n    normalized.includes('context') // Match traceContext, spanContext, etc.\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check if a function that takes ctx returns another function (factory pattern)\n * vs returning a value directly (immediate execution pattern)\n *\n * IMPORTANT: For async functions, we skip probing entirely and assume immediate execution.\n * This is because:\n * - Factory pattern: `(ctx) => async (...args) => result` - outer function is SYNC\n * - Immediate execution: `async (ctx) => result` - function itself is ASYNC\n *\n * Probing async functions by executing them causes side effects (like creating orphan spans)\n * because the async function starts executing synchronously until the first await.\n */\nfunction isFactoryReturningFunction(\n  fnWithCtx: (ctx: TraceContext) => unknown,\n): boolean {\n  // Async functions with ctx parameter are always immediate execution\n  // because factory patterns have a sync outer function that returns the async inner\n  if (isAsyncFunction(fnWithCtx)) {\n    return false;\n  }\n\n  try {\n    const result = fnWithCtx(createDummyCtx());\n    return typeof result === 'function';\n  } catch {\n    // If the function throws when called with dummy ctx, assume it's immediate execution\n    // since factory functions typically just return a function and don't execute logic\n    return false;\n  }\n}\n\nfunction isTraceFactoryFunction<TArgs extends unknown[], TReturn>(\n  fn:\n    | ((...args: TArgs) => TReturn)\n    | ((ctx: TraceContext) => (...args: TArgs) => TReturn),\n): fn is (ctx: TraceContext) => (...args: TArgs) => TReturn {\n  if (typeof fn !== 'function') {\n    return false;\n  }\n\n  if (hasFactoryMark(fn)) {\n    return true;\n  }\n\n  if (looksLikeTraceFactory(fn as GenericFunction)) {\n    markAsTraceFactory(fn);\n    return true;\n  }\n\n  return false;\n}\n\nfunction ensureTraceFactory<TArgs extends unknown[], TReturn>(\n  fnOrFactory:\n    | ((...args: TArgs) => TReturn | Promise<TReturn>)\n    | ((ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>),\n): (ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn> {\n  if (isTraceFactoryFunction(fnOrFactory)) {\n    return fnOrFactory;\n  }\n\n  const plainFn = fnOrFactory as (...args: TArgs) => TReturn | Promise<TReturn>;\n  const factory = (ctx: TraceContext) => {\n    void ctx;\n    return plainFn;\n  };\n  markAsTraceFactory(factory);\n  return factory;\n}\n\ntype WrappedFunction<TArgs extends unknown[], TReturn> = (\n  ...args: TArgs\n) => TReturn | Promise<TReturn>;\n\nfunction wrapFactoryWithTracing<TArgs extends unknown[], TReturn>(\n  fnOrFactory:\n    | ((...args: TArgs) => TReturn | Promise<TReturn>)\n    | ((ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>),\n  options: TracingOptions<TArgs, TReturn>,\n  variableName?: string,\n): WrappedFunction<TArgs, TReturn> {\n  const factory = ensureTraceFactory(fnOrFactory);\n\n  // Get the inner function (the actual function being traced)\n  const sampleFn = factory(createDummyCtx());\n\n  // Infer function name with priority:\n  // 1. Explicit variable name (from instrument() or explicit name parameter)\n  // 2. Inner function name (named function expressions - e.g., \"async function createUser\")\n  // 3. Variable name from call stack (inferred from const assignment, for arrow functions)\n  // 4. Factory function name (for cases where factory itself is named)\n  const innerFunctionName = inferFunctionName(\n    sampleFn as InstrumentableFunction,\n  );\n  const callStackVariableName = innerFunctionName\n    ? undefined\n    : inferVariableNameFromCallStack(); // Only infer from call stack if no inner function name\n  const factoryName = inferFunctionName(factory as InstrumentableFunction);\n  const effectiveVariableName =\n    variableName || innerFunctionName || callStackVariableName || factoryName;\n\n  const useAsyncWrapper = isAsyncFunction(sampleFn);\n\n  if (useAsyncWrapper) {\n    return wrapWithTracing(\n      factory as (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n      options,\n      effectiveVariableName,\n    ) as WrappedFunction<TArgs, TReturn>;\n  }\n\n  return wrapWithTracingSync(\n    factory as (ctx: TraceContext) => (...args: TArgs) => TReturn,\n    options,\n    effectiveVariableName,\n  ) as WrappedFunction<TArgs, TReturn>;\n}\n\n/**\n * Common options for functional tracing\n */\nexport interface TracingOptions<\n  TArgs extends unknown[] = unknown[],\n  TReturn = unknown,\n> {\n  /**\n   * Span name (highest priority)\n   * If provided, this is used as the span name\n   */\n  name?: string;\n\n  /**\n   * Service name (used to compose final span name)\n   * If name not provided, span name becomes: ${serviceName}.${functionName}\n   */\n  serviceName?: string;\n\n  /**\n   * Sampling strategy\n   * @default AlwaysSampler\n   */\n  sampler?: Sampler;\n\n  /**\n   * Enable metrics collection (counter, histogram)\n   * @default false\n   */\n  withMetrics?: boolean;\n\n  /**\n   * Extract attributes from function arguments\n   */\n  attributesFromArgs?: (args: TArgs) => Record<string, unknown>;\n\n  /**\n   * Extract attributes from function result\n   */\n  attributesFromResult?: (result: TReturn) => Record<string, unknown>;\n\n  /**\n   * Start a new root span instead of creating a child\n   * Useful for serverless entry points\n   * @default false\n   */\n  startNewRoot?: boolean;\n\n  /**\n   * Flush events queue when span ends\n   * Only flushes on root spans (to avoid excessive flushing)\n   * @default true\n   */\n  flushOnRootSpanEnd?: boolean;\n\n  /**\n   * Span kind for semantic convention compliance\n   * Used for messaging (PRODUCER/CONSUMER), HTTP (CLIENT/SERVER), etc.\n   * @default SpanKind.INTERNAL\n   */\n  spanKind?: import('@opentelemetry/api').SpanKind;\n}\n\n/**\n * Options for instrument() batch instrumentation\n */\nexport interface InstrumentOptions<\n  T extends Record<string, InstrumentableFunction> = Record<\n    string,\n    InstrumentableFunction\n  >,\n> extends TracingOptions {\n  /** Functions to instrument */\n  functions: T;\n  /**\n   * Per-function configuration overrides\n   */\n  overrides?: Record<string, Partial<TracingOptions>>;\n\n  /**\n   * Functions to skip (won't be instrumented)\n   * Supports:\n   * - String keys: 'functionName'\n   * - RegExp: /^_internal/\n   * - Predicate: (key, fn) => boolean\n   *\n   * By default, functions starting with _ are skipped\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  skip?: (string | RegExp | ((key: string, fn: Function) => boolean))[];\n}\n\n// Maximum error message length to prevent span bloat\nconst MAX_ERROR_MESSAGE_LENGTH = 500;\n\nfunction createDummyCtx<\n  TBaggage extends Record<string, unknown> | undefined = undefined,\n>(): TraceContext<TBaggage> {\n  return {\n    traceId: '',\n    spanId: '',\n    correlationId: '',\n    setAttribute: () => {},\n    setAttributes: () => {},\n    setStatus: () => {},\n    recordException: () => {},\n    addEvent: () => {},\n    addLink: () => {},\n    addLinks: () => {},\n    updateName: () => {},\n    isRecording: () => false,\n    getBaggage: () => {},\n    setBaggage: () => '',\n    deleteBaggage: () => {},\n    getAllBaggage: () => new Map(),\n  } as unknown as TraceContext<TBaggage>;\n}\n\nfunction isAsyncFunction(fn: unknown): boolean {\n  return typeof fn === 'function' && fn.constructor?.name === 'AsyncFunction';\n}\n\n// Symbol to prevent double-instrumentation (idempotency flag)\nconst INSTRUMENTED_SYMBOL = Symbol.for('autotel.functional.instrumented');\n\ntype InstrumentedFlag = {\n  [INSTRUMENTED_SYMBOL]?: true;\n};\n\nfunction hasInstrumentationFlag(value: unknown): value is InstrumentedFlag {\n  return (\n    (typeof value === 'function' || typeof value === 'object') &&\n    value !== null &&\n    Boolean((value as InstrumentedFlag)[INSTRUMENTED_SYMBOL])\n  );\n}\n\n/**\n * Truncate error message to prevent span bloat\n */\nfunction truncateErrorMessage(message: string): string {\n  if (message.length <= MAX_ERROR_MESSAGE_LENGTH) {\n    return message;\n  }\n  return `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}... (truncated)`;\n}\n\ntype InstrumentableFunction<\n  TArgs extends unknown[] = unknown[],\n  TReturn = unknown,\n> = ((...args: TArgs) => TReturn | Promise<TReturn>) & {\n  displayName?: string;\n  name?: string;\n};\n\n/**\n * Try to infer function name from function properties\n * Checks for displayName, name, or other metadata that might be set\n */\nfunction inferFunctionName<\n  TArgs extends unknown[] = unknown[],\n  TReturn = unknown,\n>(fn: InstrumentableFunction<TArgs, TReturn>): string | undefined {\n  // Check for displayName property (sometimes set by bundlers)\n  const displayName = (fn as { displayName?: string }).displayName;\n  if (displayName) {\n    return displayName;\n  }\n\n  // Check function.name (works for named functions and modern arrow function assignment)\n  // Note: Empty string is falsy, so this handles both undefined and ''\n  if (fn.name && fn.name !== 'anonymous' && fn.name !== '') {\n    return fn.name;\n  }\n\n  // Try to extract name from function source (for function declarations)\n  const source = Function.prototype.toString.call(fn);\n  const match = source.match(/function\\s+([^(\\s]+)/);\n  if (match && match[1] && match[1] !== 'anonymous') {\n    return match[1];\n  }\n\n  return undefined;\n}\n\n/**\n * Determine span name using priority:\n * 1. Explicit name option\n * 2. serviceName + functionName\n * 3. Inferred from function/variable name (including stack trace fallback)\n * 4. Fallback to 'unknown'\n */\nfunction getSpanName<TArgs extends unknown[], TReturn>(\n  options: TracingOptions<TArgs, TReturn>,\n  fn: InstrumentableFunction<TArgs, TReturn>,\n  variableName?: string,\n): string {\n  // 1. Explicit name\n  if (options.name) {\n    return options.name;\n  }\n\n  // 2. Try variable name, function name, or function properties\n  let fnName = variableName || inferFunctionName(fn);\n\n  // Default to 'anonymous' if still no name\n  fnName = fnName || 'anonymous';\n\n  // 2. serviceName + functionName\n  if (options.serviceName) {\n    return `${options.serviceName}.${fnName}`;\n  }\n\n  // 3. Inferred from function name\n  if (fnName && fnName !== 'anonymous') {\n    return fnName;\n  }\n\n  // 4. Fallback\n  return 'unknown';\n}\n\n/**\n * Check if function should be skipped\n */\nfunction shouldSkip(\n  key: string,\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  fn: Function,\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  skip?: (string | RegExp | ((key: string, fn: Function) => boolean))[],\n): boolean {\n  // Default: skip functions starting with _\n  if (key.startsWith('_')) {\n    return true;\n  }\n\n  if (!skip || skip.length === 0) {\n    return false;\n  }\n\n  for (const rule of skip) {\n    if (typeof rule === 'string' && key === rule) {\n      return true;\n    } else if (rule instanceof RegExp && rule.test(key)) {\n      return true;\n    } else if (typeof rule === 'function' && rule(key, fn)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Get current trace context value (internal helper)\n *\n * Returns base context (trace IDs) + span methods from the active span.\n */\nfunction getCtxValue<\n  TBaggage extends Record<string, unknown> | undefined = undefined,\n>(): TraceContext<TBaggage> | null {\n  const activeSpan = otelTrace.getActiveSpan();\n  if (!activeSpan) return null;\n\n  // Use shared utility to create trace context\n  return createTraceContext<TBaggage>(activeSpan);\n}\n\n/**\n * Context object that lazily evaluates the active span on property access\n *\n * Access trace context directly without function call syntax.\n *\n * @example\n * ```typescript\n * import { trace, ctx } from 'autotel'\n *\n * export const createUser = trace(async (data) => {\n *   // Direct property access - no function call!\n *   if (ctx.traceId) {\n *     ctx.setAttribute('user.id', data.id)\n *     console.log('Trace:', ctx.traceId)\n *   }\n * })\n * ```\n */\nexport const ctx = new Proxy(\n  {},\n  {\n    get(_target, prop) {\n      const ctxValue = getCtxValue();\n      if (!ctxValue) {\n        return;\n      }\n      return ctxValue[prop as keyof typeof ctxValue];\n    },\n\n    has(_target, prop) {\n      const ctxValue = getCtxValue();\n      if (!ctxValue) {\n        return false;\n      }\n      return prop in ctxValue;\n    },\n\n    ownKeys() {\n      const ctxValue = getCtxValue();\n      if (!ctxValue) {\n        return [];\n      }\n      return Object.keys(ctxValue);\n    },\n\n    getOwnPropertyDescriptor(_target, prop) {\n      const ctxValue = getCtxValue();\n      if (!ctxValue) {\n        return;\n      }\n      return Object.getOwnPropertyDescriptor(ctxValue, prop);\n    },\n  },\n);\n\n/**\n * Core tracing wrapper for async functions (internal implementation)\n */\nfunction wrapWithTracing<TArgs extends unknown[], TReturn>(\n  fnFactory: (\n    ctx: TraceContext,\n  ) => (...args: TArgs) => TReturn | Promise<TReturn>,\n  options: TracingOptions<TArgs, TReturn>,\n  variableName?: string,\n): (...args: TArgs) => Promise<TReturn> {\n  // Idempotency check: if already instrumented, return as-is\n  if (hasInstrumentationFlag(fnFactory)) {\n    // Already instrumented - proceed\n  }\n\n  const config = getConfig();\n  const tracer = config.tracer;\n  const meter = config.meter;\n  const sampler = options.sampler || new AlwaysSampler();\n\n  const tempFn = fnFactory(createDummyCtx());\n  const spanName = getSpanName(options, tempFn, variableName);\n\n  const callCounter = options.withMetrics\n    ? meter.createCounter(`${spanName}.calls`, {\n        description: `Call count for ${spanName}`,\n        unit: '1',\n      })\n    : undefined;\n\n  const durationHistogram = options.withMetrics\n    ? meter.createHistogram(`${spanName}.duration`, {\n        description: `Duration for ${spanName}`,\n        unit: 'ms',\n      })\n    : undefined;\n\n  const wrappedFunction = async function wrappedFunction(\n    this: unknown,\n    ...args: TArgs\n  ): Promise<TReturn> {\n    const samplingContext: SamplingContext = {\n      operationName: spanName,\n      args,\n      metadata: {},\n    };\n\n    const shouldSample = sampler.shouldSample(samplingContext);\n    const needsTailSampling =\n      'needsTailSampling' in sampler &&\n      typeof sampler.needsTailSampling === 'function'\n        ? sampler.needsTailSampling()\n        : false;\n\n    if (!shouldSample && !needsTailSampling) {\n      const fn = fnFactory(createDummyCtx());\n      return await fn.call(this, ...args);\n    }\n\n    const startTime = performance.now();\n    const isRootSpan =\n      options.startNewRoot || otelTrace.getActiveSpan() === undefined;\n    const shouldAutoFlush =\n      options.flushOnRootSpanEnd ?? getInitConfig()?.flushOnRootSpanEnd ?? true;\n    const shouldAutoFlushSpans = getInitConfig()?.forceFlushOnShutdown ?? false;\n\n    const flushIfNeeded = async () => {\n      if (!shouldAutoFlush || !isRootSpan) return;\n\n      try {\n        // Flush events queue\n        const queue = getEventQueue();\n        if (queue && queue.size() > 0) {\n          await queue.flush();\n        }\n\n        // Flush OpenTelemetry spans if enabled\n        if (shouldAutoFlushSpans) {\n          const sdk = getSdk();\n          if (sdk) {\n            try {\n              // Type assertion needed as getTracerProvider is not in the public NodeSDK interface\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              const sdkAny = sdk as any;\n              if (typeof sdkAny.getTracerProvider === 'function') {\n                const tracerProvider = sdkAny.getTracerProvider();\n                if (\n                  tracerProvider &&\n                  typeof tracerProvider.forceFlush === 'function'\n                ) {\n                  await tracerProvider.forceFlush();\n                }\n              }\n            } catch {\n              // Ignore errors when accessing tracer provider (may not be available in test mocks)\n            }\n          }\n        }\n      } catch (error) {\n        const initConfig = getInitConfig();\n        const logger = initConfig?.logger;\n        if (logger?.error) {\n          logger.error(\n            {\n              err: error instanceof Error ? error : undefined,\n            },\n            `[autotel] Auto-flush failed${error instanceof Error ? '' : `: ${String(error)}`}`,\n          );\n        }\n      }\n    };\n\n    // Build span options including root and kind\n    const spanOptions: import('@opentelemetry/api').SpanOptions = {};\n    if (options.startNewRoot) {\n      spanOptions.root = true;\n    }\n    if (options.spanKind !== undefined) {\n      spanOptions.kind = options.spanKind;\n    }\n\n    return tracer.startActiveSpan(spanName, spanOptions, async (span) => {\n      // Run within operation context so events can auto-capture operation.name\n      return runInOperationContext(spanName, async () => {\n        let shouldKeepSpan = true;\n\n        setSpanName(span, spanName);\n\n        // Initialize context storage with the active context BEFORE creating trace context\n        const initialContext = context.active();\n        const contextStorage = getContextStorage();\n        if (!contextStorage.getStore()) {\n          contextStorage.enterWith(initialContext);\n        }\n\n        const ctxValue = createTraceContext(span);\n        const fn = fnFactory(ctxValue);\n        const argsAttributes = options.attributesFromArgs\n          ? options.attributesFromArgs(args)\n          : {};\n\n        const handleTailSampling = (\n          success: boolean,\n          duration: number,\n          error?: unknown,\n        ) => {\n          if (\n            needsTailSampling &&\n            'shouldKeepTrace' in sampler &&\n            typeof sampler.shouldKeepTrace === 'function'\n          ) {\n            shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {\n              success,\n              duration,\n              error,\n            });\n            span.setAttribute('sampling.tail.keep', shouldKeepSpan);\n            span.setAttribute('sampling.tail.evaluated', true);\n          }\n        };\n\n        const onSuccess = async (result: TReturn) => {\n          const duration = performance.now() - startTime;\n\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'success',\n          });\n\n          durationHistogram?.record(duration, {\n            operation: spanName,\n            status: 'success',\n          });\n\n          const resultAttributes = options.attributesFromResult\n            ? options.attributesFromResult(result)\n            : {};\n\n          span.setStatus({ code: SpanStatusCode.OK });\n          span.setAttributes({\n            ...argsAttributes,\n            ...resultAttributes,\n            'operation.name': spanName,\n            'code.function': spanName,\n            'operation.duration': duration,\n            'operation.success': true,\n          });\n\n          handleTailSampling(true, duration);\n\n          span.end();\n          await flushIfNeeded();\n          return result;\n        };\n\n        const onError = async (error: unknown): Promise<never> => {\n          const duration = performance.now() - startTime;\n\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'error',\n          });\n\n          durationHistogram?.record(duration, {\n            operation: spanName,\n            status: 'error',\n          });\n\n          const errorMessage =\n            error instanceof Error ? error.message : 'Unknown error';\n          const truncatedMessage = truncateErrorMessage(errorMessage);\n\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: truncatedMessage,\n          });\n\n          span.setAttributes({\n            ...argsAttributes,\n            'operation.name': spanName,\n            'code.function': spanName,\n            'operation.duration': duration,\n            'operation.success': false,\n            error: true,\n            'exception.type':\n              error instanceof Error ? error.constructor.name : 'Error',\n            'exception.message': truncatedMessage,\n          });\n\n          if (error instanceof Error && error.stack) {\n            span.setAttribute(\n              'exception.stack',\n              error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH),\n            );\n          }\n\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n\n          handleTailSampling(false, duration, error);\n\n          span.end();\n          await flushIfNeeded();\n          throw error;\n        };\n\n        try {\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'started',\n          });\n\n          // Execute the user's function with the updated context\n          // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations\n          // (like BaggageSpanProcessor, child spans, etc.)\n          // We use getActiveContextWithBaggage() which checks the stored context,\n          // so if baggage is set during execution, it will be picked up\n          const executeWithContext = async () => {\n            // Get the current context (may have been updated by ctx.setBaggage())\n            const currentContext = getActiveContextWithBaggage();\n            // Establish the context in OpenTelemetry's context manager\n            return context.with(currentContext, async () => {\n              return fn.call(this, ...args);\n            });\n          };\n          const result = await executeWithContext();\n\n          return await onSuccess(result);\n        } catch (error) {\n          await onError(error);\n          throw error;\n        }\n      });\n    });\n  };\n\n  // Mark as instrumented to prevent double-wrapping\n  (wrappedFunction as InstrumentedFlag)[INSTRUMENTED_SYMBOL] = true;\n\n  Object.defineProperty(wrappedFunction, 'name', {\n    value: tempFn.name || 'trace',\n    configurable: true,\n  });\n\n  return wrappedFunction;\n}\n\n/**\n * Core tracing wrapper for sync functions (internal implementation)\n */\nfunction wrapWithTracingSync<TArgs extends unknown[], TReturn>(\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n  options: TracingOptions<TArgs, TReturn>,\n  variableName?: string,\n): (...args: TArgs) => TReturn {\n  // Idempotency check: if already instrumented, return as-is\n  if (hasInstrumentationFlag(fnFactory)) {\n    // If already instrumented, we need to extract the original factory\n    // For now, we'll just proceed - this edge case is handled by the wrapped function check\n  }\n\n  const config = getConfig();\n  const tracer = config.tracer;\n  const meter = config.meter;\n  const sampler = options.sampler || new AlwaysSampler();\n\n  // We need to get a reference function name for span naming\n  // Create a minimal dummy context just for extracting the function name\n  // This won't affect actual tracing - we use the real context inside the span\n  const tempFn = fnFactory(createDummyCtx());\n  const spanName = getSpanName(options, tempFn, variableName);\n\n  // Metrics setup (if enabled)\n  const callCounter = options.withMetrics\n    ? meter.createCounter(`${spanName}.calls`, {\n        description: `Call count for ${spanName}`,\n        unit: '1',\n      })\n    : undefined;\n\n  const durationHistogram = options.withMetrics\n    ? meter.createHistogram(`${spanName}.duration`, {\n        description: `Duration for ${spanName}`,\n        unit: 'ms',\n      })\n    : undefined;\n\n  // Return wrapped function\n  function wrappedFunction(\n    this: unknown,\n    ...args: TArgs\n  ): TReturn | Promise<TReturn> {\n    const samplingContext: SamplingContext = {\n      operationName: spanName,\n      args,\n      metadata: {},\n    };\n\n    const shouldSample = sampler.shouldSample(samplingContext);\n    const needsTailSampling =\n      'needsTailSampling' in sampler &&\n      typeof sampler.needsTailSampling === 'function'\n        ? sampler.needsTailSampling()\n        : false;\n\n    // If not sampling and no tail sampling, execute without tracing\n    if (!shouldSample && !needsTailSampling) {\n      const fn = fnFactory(createDummyCtx());\n      return fn.call(this, ...args);\n    }\n\n    const startTime = performance.now();\n\n    // Track if this is a root span for auto-flush\n    const isRootSpan =\n      options.startNewRoot || otelTrace.getActiveSpan() === undefined;\n    const shouldAutoFlush =\n      options.flushOnRootSpanEnd ?? getInitConfig()?.flushOnRootSpanEnd ?? true;\n    const shouldAutoFlushSpans = getInitConfig()?.forceFlushOnShutdown ?? false;\n\n    // Note: This is intentionally fire-and-forget (void) for synchronous functions.\n    // Synchronous functions cannot await flush completion without blocking execution.\n    // The forceFlushOnShutdown guarantee only applies to async functions.\n    const flushIfNeeded = () => {\n      if (!shouldAutoFlush || !isRootSpan) return;\n\n      // Flush events queue\n      const queue = getEventQueue();\n      if (queue && queue.size() > 0) {\n        void queue.flush().catch((error) => {\n          const initConfig = getInitConfig();\n          const logger = initConfig?.logger;\n          if (logger?.error) {\n            logger.error(\n              {\n                err: error instanceof Error ? error : undefined,\n              },\n              `[autotel] Auto-flush failed${error instanceof Error ? '' : `: ${String(error)}`}`,\n            );\n          }\n        });\n      }\n\n      // Flush OpenTelemetry spans if enabled\n      if (shouldAutoFlushSpans) {\n        const sdk = getSdk();\n        if (sdk) {\n          try {\n            // Type assertion needed as getTracerProvider is not in the public NodeSDK interface\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const sdkAny = sdk as any;\n            if (typeof sdkAny.getTracerProvider === 'function') {\n              const tracerProvider = sdkAny.getTracerProvider();\n              if (\n                tracerProvider &&\n                typeof tracerProvider.forceFlush === 'function'\n              ) {\n                void tracerProvider.forceFlush().catch((error: unknown) => {\n                  const initConfig = getInitConfig();\n                  const logger = initConfig?.logger;\n                  if (logger?.error) {\n                    logger.error(\n                      {\n                        err: error instanceof Error ? error : undefined,\n                      },\n                      `[autotel] Span flush failed${error instanceof Error ? '' : `: ${String(error)}`}`,\n                    );\n                  }\n                });\n              }\n            }\n          } catch {\n            // Ignore errors when accessing tracer provider (may not be available in test mocks)\n          }\n        }\n      }\n    };\n\n    // Build span options including root and kind\n    const spanOptions: import('@opentelemetry/api').SpanOptions = {};\n    if (options.startNewRoot) {\n      spanOptions.root = true;\n    }\n    if (options.spanKind !== undefined) {\n      spanOptions.kind = options.spanKind;\n    }\n\n    return tracer.startActiveSpan(spanName, spanOptions, (span) => {\n      // Run within operation context so events can auto-capture operation.name\n      return runInOperationContext(spanName, () => {\n        let shouldKeepSpan = true;\n\n        // Store span name for trace context helpers\n        setSpanName(span, spanName);\n\n        // Create trace context for this span using shared utility\n        const ctxValue = createTraceContext(span);\n\n        // Get the actual function from the factory\n        const fn = fnFactory(ctxValue);\n\n        // Extract attributes only when actually tracing\n        // This avoids expensive preprocessing when sampling rejects the trace\n        const argsAttributes = options.attributesFromArgs\n          ? options.attributesFromArgs(args)\n          : {};\n\n        const handleTailSampling = (\n          success: boolean,\n          duration: number,\n          error?: unknown,\n        ) => {\n          if (\n            needsTailSampling &&\n            'shouldKeepTrace' in sampler &&\n            typeof sampler.shouldKeepTrace === 'function'\n          ) {\n            shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {\n              success,\n              duration,\n              error,\n            });\n            span.setAttribute('sampling.tail.keep', shouldKeepSpan);\n            span.setAttribute('sampling.tail.evaluated', true);\n          }\n        };\n\n        const onSuccess = (result: TReturn) => {\n          const duration = performance.now() - startTime;\n\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'success',\n          });\n\n          durationHistogram?.record(duration, {\n            operation: spanName,\n            status: 'success',\n          });\n\n          const resultAttributes = options.attributesFromResult\n            ? options.attributesFromResult(result)\n            : {};\n\n          span.setStatus({ code: SpanStatusCode.OK });\n          span.setAttributes({\n            ...argsAttributes,\n            ...resultAttributes,\n            'operation.name': spanName,\n            'code.function': spanName,\n            'operation.duration': duration,\n            'operation.success': true,\n          });\n\n          handleTailSampling(true, duration);\n\n          span.end();\n          void flushIfNeeded();\n          return result;\n        };\n\n        const onError = (error: unknown): never => {\n          const duration = performance.now() - startTime;\n\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'error',\n          });\n\n          durationHistogram?.record(duration, {\n            operation: spanName,\n            status: 'error',\n          });\n\n          const errorMessage =\n            error instanceof Error ? error.message : 'Unknown error';\n          const truncatedMessage = truncateErrorMessage(errorMessage);\n\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: truncatedMessage,\n          });\n\n          span.setAttributes({\n            ...argsAttributes,\n            'operation.name': spanName,\n            'code.function': spanName,\n            'operation.duration': duration,\n            'operation.success': false,\n            error: true,\n            'exception.type':\n              error instanceof Error ? error.constructor.name : 'Error',\n            'exception.message': truncatedMessage,\n          });\n\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n\n          handleTailSampling(false, duration, error);\n\n          span.end();\n          void flushIfNeeded();\n          throw error;\n        };\n\n        try {\n          callCounter?.add(1, {\n            operation: spanName,\n            status: 'started',\n          });\n\n          const result = fn.call(this, ...args);\n\n          if (result instanceof Promise) {\n            return result.then(onSuccess, onError);\n          }\n\n          return onSuccess(result);\n        } catch (error) {\n          return onError(error);\n        }\n      });\n    });\n  }\n\n  // Mark as instrumented to prevent double-wrapping\n  (wrappedFunction as InstrumentedFlag)[INSTRUMENTED_SYMBOL] = true;\n\n  // Preserve function name for better debugging\n  // Use the same tempFn we created earlier for span naming\n  Object.defineProperty(wrappedFunction, 'name', {\n    value: tempFn.name || 'trace',\n    configurable: true,\n  });\n\n  return wrappedFunction as unknown as (...args: TArgs) => TReturn;\n}\n\n/**\n * Execute a function immediately within a trace span\n * Used for the immediate execution pattern: trace((ctx) => result)\n */\nfunction executeImmediately<TReturn = unknown>(\n  fn: (ctx: TraceContext) => TReturn | Promise<TReturn>,\n  options: TracingOptions<unknown[], unknown>,\n): TReturn | Promise<TReturn> {\n  const config = getConfig();\n  const tracer = config.tracer;\n  const meter = config.meter;\n  const sampler = options.sampler || new AlwaysSampler();\n\n  // Get span name from options or use 'anonymous'\n  const spanName = options.name || 'anonymous';\n\n  const samplingContext: SamplingContext = {\n    operationName: spanName,\n    args: [],\n    metadata: {},\n  };\n\n  const shouldSample = sampler.shouldSample(samplingContext);\n  const needsTailSampling =\n    'needsTailSampling' in sampler &&\n    typeof sampler.needsTailSampling === 'function'\n      ? sampler.needsTailSampling()\n      : false;\n\n  if (!shouldSample && !needsTailSampling) {\n    return fn(createDummyCtx());\n  }\n\n  const startTime = performance.now();\n  const isRootSpan =\n    options.startNewRoot || otelTrace.getActiveSpan() === undefined;\n  const shouldAutoFlush =\n    options.flushOnRootSpanEnd ?? getInitConfig()?.flushOnRootSpanEnd ?? true;\n  const shouldAutoFlushSpans = getInitConfig()?.forceFlushOnShutdown ?? false;\n\n  const callCounter = options.withMetrics\n    ? meter.createCounter(`${spanName}.calls`, {\n        description: `Call count for ${spanName}`,\n        unit: '1',\n      })\n    : undefined;\n\n  const durationHistogram = options.withMetrics\n    ? meter.createHistogram(`${spanName}.duration`, {\n        description: `Duration for ${spanName}`,\n        unit: 'ms',\n      })\n    : undefined;\n\n  const flushIfNeeded = async () => {\n    if (!shouldAutoFlush || !isRootSpan) return;\n\n    try {\n      // Flush events queue\n      const queue = getEventQueue();\n      if (queue && queue.size() > 0) {\n        await queue.flush();\n      }\n\n      // Flush OpenTelemetry spans if enabled\n      if (shouldAutoFlushSpans) {\n        const sdk = getSdk();\n        if (sdk) {\n          try {\n            // Type assertion needed as getTracerProvider is not in the public NodeSDK interface\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const sdkAny = sdk as any;\n            if (typeof sdkAny.getTracerProvider === 'function') {\n              const tracerProvider = sdkAny.getTracerProvider();\n              if (\n                tracerProvider &&\n                typeof tracerProvider.forceFlush === 'function'\n              ) {\n                await tracerProvider.forceFlush();\n              }\n            }\n          } catch {\n            // Ignore errors when accessing tracer provider (may not be available in test mocks)\n          }\n        }\n      }\n    } catch (error) {\n      const initConfig = getInitConfig();\n      const logger = initConfig?.logger;\n      if (logger?.error) {\n        logger.error(\n          {\n            err: error instanceof Error ? error : undefined,\n          },\n          `[autotel] Auto-flush failed${error instanceof Error ? '' : `: ${String(error)}`}`,\n        );\n      }\n    }\n  };\n\n  // Build span options including root and kind\n  const spanOptions: import('@opentelemetry/api').SpanOptions = {};\n  if (options.startNewRoot) {\n    spanOptions.root = true;\n  }\n  if (options.spanKind !== undefined) {\n    spanOptions.kind = options.spanKind;\n  }\n\n  return tracer.startActiveSpan(spanName, spanOptions, (span) => {\n    return runInOperationContext(spanName, () => {\n      let shouldKeepSpan = true;\n\n      setSpanName(span, spanName);\n      const ctxValue = createTraceContext(span);\n\n      const handleTailSampling = (\n        success: boolean,\n        duration: number,\n        error?: unknown,\n      ) => {\n        if (\n          needsTailSampling &&\n          'shouldKeepTrace' in sampler &&\n          typeof sampler.shouldKeepTrace === 'function'\n        ) {\n          shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {\n            success,\n            duration,\n            error,\n          });\n          span.setAttribute('sampling.tail.keep', shouldKeepSpan);\n          span.setAttribute('sampling.tail.evaluated', true);\n        }\n      };\n\n      // Sync handlers for synchronous results (can't await)\n      // NOTE: forceFlushOnShutdown will NOT block for synchronous trace() calls\n      // Flush is fire-and-forget, so spans may be dropped if process exits immediately\n      const onSuccessSync = (result: TReturn) => {\n        const duration = performance.now() - startTime;\n\n        callCounter?.add(1, {\n          operation: spanName,\n          status: 'success',\n        });\n\n        durationHistogram?.record(duration, {\n          operation: spanName,\n          status: 'success',\n        });\n\n        span.setStatus({ code: SpanStatusCode.OK });\n        span.setAttributes({\n          'operation.name': spanName,\n          'code.function': spanName,\n          'operation.duration': duration,\n          'operation.success': true,\n        });\n\n        handleTailSampling(true, duration);\n\n        span.end();\n        void flushIfNeeded();\n        return result;\n      };\n\n      const onErrorSync = (error: unknown): never => {\n        const duration = performance.now() - startTime;\n\n        callCounter?.add(1, {\n          operation: spanName,\n          status: 'error',\n        });\n\n        durationHistogram?.record(duration, {\n          operation: spanName,\n          status: 'error',\n        });\n\n        const errorMessage =\n          error instanceof Error ? error.message : 'Unknown error';\n        const truncatedMessage = truncateErrorMessage(errorMessage);\n\n        span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: truncatedMessage,\n        });\n\n        span.setAttributes({\n          'operation.name': spanName,\n          'code.function': spanName,\n          'operation.duration': duration,\n          'operation.success': false,\n          error: true,\n          'exception.type':\n            error instanceof Error ? error.constructor.name : 'Error',\n          'exception.message': truncatedMessage,\n        });\n\n        if (error instanceof Error && error.stack) {\n          span.setAttribute(\n            'exception.stack',\n            error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH),\n          );\n        }\n\n        span.recordException(\n          error instanceof Error ? error : new Error(String(error)),\n        );\n\n        handleTailSampling(false, duration, error);\n\n        span.end();\n        void flushIfNeeded();\n        throw error;\n      };\n\n      // Async handlers for Promise results (await flush)\n      const onSuccessAsync = async (result: TReturn) => {\n        const duration = performance.now() - startTime;\n\n        callCounter?.add(1, {\n          operation: spanName,\n          status: 'success',\n        });\n\n        durationHistogram?.record(duration, {\n          operation: spanName,\n          status: 'success',\n        });\n\n        span.setStatus({ code: SpanStatusCode.OK });\n        span.setAttributes({\n          'operation.name': spanName,\n          'code.function': spanName,\n          'operation.duration': duration,\n          'operation.success': true,\n        });\n\n        handleTailSampling(true, duration);\n\n        span.end();\n        await flushIfNeeded();\n        return result;\n      };\n\n      const onErrorAsync = async (error: unknown): Promise<never> => {\n        const duration = performance.now() - startTime;\n\n        callCounter?.add(1, {\n          operation: spanName,\n          status: 'error',\n        });\n\n        durationHistogram?.record(duration, {\n          operation: spanName,\n          status: 'error',\n        });\n\n        const errorMessage =\n          error instanceof Error ? error.message : 'Unknown error';\n        const truncatedMessage = truncateErrorMessage(errorMessage);\n\n        span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: truncatedMessage,\n        });\n\n        span.setAttributes({\n          'operation.name': spanName,\n          'code.function': spanName,\n          'operation.duration': duration,\n          'operation.success': false,\n          error: true,\n          'exception.type':\n            error instanceof Error ? error.constructor.name : 'Error',\n          'exception.message': truncatedMessage,\n        });\n\n        if (error instanceof Error && error.stack) {\n          span.setAttribute(\n            'exception.stack',\n            error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH),\n          );\n        }\n\n        span.recordException(\n          error instanceof Error ? error : new Error(String(error)),\n        );\n\n        handleTailSampling(false, duration, error);\n\n        span.end();\n        await flushIfNeeded();\n        throw error;\n      };\n\n      try {\n        callCounter?.add(1, {\n          operation: spanName,\n          status: 'started',\n        });\n\n        const result = fn(ctxValue);\n\n        // Check if result is a Promise - use async handlers to await flush\n        if (result instanceof Promise) {\n          return result.then(onSuccessAsync, onErrorAsync);\n        }\n\n        // Synchronous result - use sync handlers\n        return onSuccessSync(result);\n      } catch (error) {\n        return onErrorSync(error);\n      }\n    });\n  });\n}\n\n/**\n * Approach 1: trace() - Zero-ceremony HOF\n *\n * Wrap a single function with automatic tracing.\n * The function receives a context object as the first parameter.\n *\n * Supports two patterns:\n * 1. **Factory pattern** - Returns a traced function: `trace(ctx => (...args) => result)`\n * 2. **Immediate execution** - Executes immediately with tracing: `trace(ctx => result)`\n *\n * @example Auto-inferred name - Plain function\n * ```typescript\n * export const createUser = trace(async (data) => {\n *   return await db.users.create(data)\n * })\n * // → Traced as \"createUser\"\n * ```\n *\n * @example Auto-inferred name - Factory pattern (with ctx access)\n * ```typescript\n * export const createUser = trace(ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * // → Traced as \"createUser\", returns wrapped function\n * ```\n *\n * @example Immediate execution - Execute once with tracing\n * ```typescript\n * // Wraps an existing function and executes immediately\n * function timed<T>(fn: () => Promise<T>): Promise<T> {\n *   return trace(async (ctx) => {\n *     ctx.setAttribute('operation', 'timed')\n *     return await fn()\n *   })\n * }\n * // → Executes immediately, returns result directly\n * ```\n *\n * @example Custom name - Plain function\n * ```typescript\n * export const createUser = trace('user.create', async (data) => {\n *   return await db.users.create(data)\n * })\n * // → Traced as \"user.create\"\n * ```\n *\n * @example Custom name - Factory pattern\n * ```typescript\n * export const createUser = trace('user.create', ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * // → Traced as \"user.create\"\n * ```\n *\n * @example Custom name - Immediate execution\n * ```typescript\n * const result = trace('fetch.user', async (ctx) => {\n *   ctx.setAttribute('userId', '123')\n *   return await fetchUser('123')\n * })\n * // → Executes immediately with span name \"fetch.user\"\n * ```\n *\n * @example Full options - Plain function\n * ```typescript\n * export const createUser = trace({\n *   name: 'user.create',\n *   sampler: new AdaptiveSampler(),\n *   withMetrics: true\n * }, async (data) => {\n *   return await db.users.create(data)\n * })\n * ```\n *\n * @example Full options - Factory pattern\n * ```typescript\n * export const createUser = trace({\n *   name: 'user.create',\n *   sampler: new AdaptiveSampler(),\n *   withMetrics: true\n * }, ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * ```\n */\n// Sync overloads - Ordered from most specific to most generic for better type inference\n\n// Single argument - Specific overloads with TraceContext first\n// Overload 1a: Immediate execution - sync function with context\nexport function trace<\n  TBaggage extends Record<string, unknown> | undefined = undefined,\n  TReturn = unknown,\n>(fn: (ctx: TraceContext<TBaggage>) => TReturn): TReturn;\n// Overload 1b: Factory sync function with no args - non-generic for type inference\nexport function trace<\n  TBaggage extends Record<string, unknown> | undefined = undefined,\n>(fnFactory: (ctx: TraceContext<TBaggage>) => () => unknown): () => unknown;\n// Overload 1c: Factory sync function - non-generic for type inference\nexport function trace<\n  TBaggage extends Record<string, unknown> | undefined = undefined,\n  TArgs extends unknown[] = unknown[],\n  TReturn = unknown,\n>(\n  fnFactory: (ctx: TraceContext<TBaggage>) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n// Overload 1d: Factory sync function with no args returning explicit type (typed generic)\nexport function trace<TReturn = unknown>(\n  fnFactory: (ctx: TraceContext) => () => TReturn,\n): () => TReturn;\n// Overload 1e: Factory sync function - use conditional type to extract signature\n// This overload is more specific and helps TypeScript infer types from factory functions\nexport function trace<\n  TFactory extends (ctx: TraceContext) => (...args: unknown[]) => unknown,\n>(fnFactory: TFactory): ExtractFunctionSignature<TFactory>;\n// Overload 1f: Generic factory sync function (fallback)\nexport function trace<TArgs extends unknown[], TReturn = unknown>(\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Single argument - Plain function overloads (no ctx parameter)\n// Overload 1g: Plain sync function with no args\nexport function trace<TReturn = unknown>(fn: () => TReturn): () => TReturn;\n// Overload 1h: Plain sync function (generic fallback)\nexport function trace<TArgs extends unknown[], TReturn = unknown>(\n  fn: (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Two arguments - name + function - Specific overloads with TraceContext first\n// Overload 2a: Name + immediate execution sync with context\n// This overload only matches functions that DON'T return functions (factories)\nexport function trace<TReturn = unknown>(\n  name: string,\n  fn: ExcludeFactoryReturn<(ctx: TraceContext) => TReturn>,\n): TReturn;\n// Overload 2b: Name + factory sync function with no args\nexport function trace<TReturn = unknown>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => () => TReturn,\n): () => TReturn;\n// Overload 2c: Name + factory sync function - non-generic for type inference\nexport function trace<TArgs extends unknown[], TReturn>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n// Overload 2d: Name + factory sync function - use conditional type to extract signature\n// This overload allows TypeScript to infer types from the factory function parameter\nexport function trace<\n  TFactory extends (ctx: TraceContext) => (...args: unknown[]) => unknown,\n>(name: string, fnFactory: TFactory): ExtractFunctionSignature<TFactory>;\n// Overload 2e: Name + factory sync function (fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Two arguments - name + function - Plain function overloads\n// Overload 2f: Name + plain sync function\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  name: string,\n  fn: (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Two arguments - options + function - Specific overloads with TraceContext first\n// Overload 3a: Options + immediate execution sync with context\nexport function trace<TReturn = unknown>(\n  options: TracingOptions<[], TReturn>,\n  fn: (ctx: TraceContext) => TReturn,\n): TReturn;\n// Overload 3b: Options + factory sync function with no args\nexport function trace<TReturn = unknown>(\n  options: TracingOptions<[], TReturn>,\n  fnFactory: (ctx: TraceContext) => () => TReturn,\n): () => TReturn;\n// Overload 3c: Options + factory sync function - non-generic for type inference\nexport function trace<TArgs extends unknown[], TReturn>(\n  options: TracingOptions<TArgs, TReturn>,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n// Overload 3d: Options + factory sync function (fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  options: TracingOptions<TArgs, TReturn>,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Two arguments - options + function - Plain function overloads\n// Overload 3e: Options + plain sync function\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  options: TracingOptions<TArgs, TReturn>,\n  fn: (...args: TArgs) => TReturn,\n): (...args: TArgs) => TReturn;\n\n// Async overloads - Ordered from most specific to most generic\n\n// Single argument - Specific async overloads with TraceContext first\n// Overload 4a: Immediate execution - async function with context\nexport function trace<TReturn = unknown>(\n  fn: (ctx: TraceContext) => Promise<TReturn>,\n): Promise<TReturn>;\n// Overload 4b: Factory async function with no args - non-generic for type inference\nexport function trace(\n  fnFactory: (ctx: TraceContext) => () => Promise<unknown>,\n): () => Promise<unknown>;\n// Overload 4c: Factory async function - non-generic for type inference\nexport function trace<TArgs extends unknown[], TReturn>(\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n// Overload 4d: Factory async function with no args (typed generic)\nexport function trace<TReturn = unknown>(\n  fnFactory: (ctx: TraceContext) => () => Promise<TReturn>,\n): () => Promise<TReturn>;\n// Overload 4e: Factory async function - use conditional type to extract signature\nexport function trace<\n  TFactory extends (\n    ctx: TraceContext,\n  ) => (...args: unknown[]) => Promise<unknown>,\n>(fnFactory: TFactory): ExtractFunctionSignature<TFactory>;\n// Overload 4f: Generic factory async function (fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Single argument - Plain async function overloads (no ctx parameter)\n// Overload 4g: Plain async function with no args\nexport function trace<TReturn = unknown>(\n  fn: () => Promise<TReturn>,\n): () => Promise<TReturn>;\n// Overload 4h: Plain async function (generic fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  fn: (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Two arguments - name + async function - Specific overloads with TraceContext first\n// Overload 5a: Name + immediate execution async with context\n// This overload only matches functions that DON'T return functions (factories)\nexport function trace<TReturn = unknown>(\n  name: string,\n  fn: ExcludeFactoryReturn<(ctx: TraceContext) => Promise<TReturn>>,\n): Promise<TReturn>;\n// Overload 5b: Name + factory async function with no args\nexport function trace<TReturn = unknown>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => () => Promise<TReturn>,\n): () => Promise<TReturn>;\n// Overload 5c: Name + factory async function - non-generic for type inference\nexport function trace<TArgs extends unknown[], TReturn>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n// Overload 5d: Name + factory async function - use conditional type to extract signature\n// This overload allows TypeScript to infer types from the factory function parameter\nexport function trace<\n  TFactory extends (\n    ctx: TraceContext,\n  ) => (...args: unknown[]) => Promise<unknown>,\n>(name: string, fnFactory: TFactory): ExtractFunctionSignature<TFactory>;\n// Overload 5e: Name + factory async function (fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  name: string,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Two arguments - name + async function - Plain function overloads\n// Overload 5f: Name + plain async function\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  name: string,\n  fn: (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Two arguments - options + async function - Specific overloads with TraceContext first\n// Overload 6a: Options + immediate execution async with context\nexport function trace<TReturn = unknown>(\n  options: TracingOptions<[], TReturn>,\n  fn: (ctx: TraceContext) => Promise<TReturn>,\n): Promise<TReturn>;\n// Overload 6b: Options + factory async function with no args\nexport function trace<TReturn = unknown>(\n  options: TracingOptions<[], TReturn>,\n  fnFactory: (ctx: TraceContext) => () => Promise<TReturn>,\n): () => Promise<TReturn>;\n// Overload 6c: Options + factory async function - non-generic for type inference\nexport function trace<TArgs extends unknown[], TReturn>(\n  options: TracingOptions<TArgs, TReturn>,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n// Overload 6d: Options + factory async function (fallback)\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  options: TracingOptions<TArgs, TReturn>,\n  fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Two arguments - options + async function - Plain function overloads\n// Overload 6e: Options + plain async function\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  options: TracingOptions<TArgs, TReturn>,\n  fn: (...args: TArgs) => Promise<TReturn>,\n): (...args: TArgs) => Promise<TReturn>;\n\n// Implementation\nexport function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(\n  fnOrNameOrOptions:\n    | ((...args: TArgs) => TReturn)\n    | ((...args: TArgs) => Promise<TReturn>)\n    | ((ctx: TraceContext) => (...args: TArgs) => TReturn)\n    | ((ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>)\n    | ((ctx: TraceContext) => TReturn)\n    | ((ctx: TraceContext) => Promise<TReturn>)\n    | string\n    | TracingOptions<TArgs, TReturn>,\n  maybeFn?:\n    | ((...args: TArgs) => TReturn)\n    | ((...args: TArgs) => Promise<TReturn>)\n    | ((ctx: TraceContext) => (...args: TArgs) => TReturn)\n    | ((ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>)\n    | ((ctx: TraceContext) => TReturn)\n    | ((ctx: TraceContext) => Promise<TReturn>),\n): WrappedFunction<TArgs, TReturn> | TReturn | Promise<TReturn> {\n  // Handle: trace(fn) - single argument\n  if (typeof fnOrNameOrOptions === 'function') {\n    // Check if it's immediate execution pattern: (ctx) => result\n    if (\n      looksLikeTraceFactory(fnOrNameOrOptions as GenericFunction) &&\n      !isFactoryReturningFunction(\n        fnOrNameOrOptions as (ctx: TraceContext) => unknown,\n      )\n    ) {\n      // Immediate execution pattern\n      return executeImmediately(\n        fnOrNameOrOptions as (ctx: TraceContext) => TReturn | Promise<TReturn>,\n        {},\n      ) as WrappedFunction<TArgs, TReturn> | TReturn | Promise<TReturn>;\n    }\n    // Factory pattern or plain function\n    return wrapFactoryWithTracing(\n      fnOrNameOrOptions as (...args: TArgs) => TReturn,\n      {} as TracingOptions<TArgs, TReturn>,\n    );\n  }\n\n  // Handle: trace(name, fn) or trace(options, fn) - two arguments\n  if (typeof fnOrNameOrOptions === 'string') {\n    if (!maybeFn) {\n      throw new Error('trace(name, fn): fn is required');\n    }\n    // Check if it's immediate execution pattern\n    if (\n      looksLikeTraceFactory(maybeFn as GenericFunction) &&\n      !isFactoryReturningFunction(maybeFn as (ctx: TraceContext) => unknown)\n    ) {\n      // Immediate execution pattern with name\n      return executeImmediately(\n        maybeFn as (ctx: TraceContext) => TReturn | Promise<TReturn>,\n        { name: fnOrNameOrOptions },\n      ) as WrappedFunction<TArgs, TReturn> | TReturn | Promise<TReturn>;\n    }\n    return wrapFactoryWithTracing(\n      maybeFn as (...args: TArgs) => TReturn,\n      { name: fnOrNameOrOptions } as TracingOptions<TArgs, TReturn>,\n    );\n  }\n\n  // Handle: trace(options, fn)\n  if (!maybeFn) {\n    throw new Error('trace(options, fn): fn is required');\n  }\n\n  // Check if it's immediate execution pattern\n  if (\n    looksLikeTraceFactory(maybeFn as GenericFunction) &&\n    !isFactoryReturningFunction(maybeFn as (ctx: TraceContext) => unknown)\n  ) {\n    // Immediate execution pattern with options\n    return executeImmediately(\n      maybeFn as (ctx: TraceContext) => TReturn | Promise<TReturn>,\n      fnOrNameOrOptions as TracingOptions<unknown[], unknown>,\n    ) as WrappedFunction<TArgs, TReturn> | TReturn | Promise<TReturn>;\n  }\n\n  return wrapFactoryWithTracing(\n    maybeFn as (...args: TArgs) => TReturn,\n    fnOrNameOrOptions as TracingOptions<TArgs, TReturn>,\n  );\n}\n\n/**\n * Approach 2: withTracing() - Middleware-style composable wrapper\n *\n * Returns a HOF that wraps functions with tracing.\n * Perfect for composition and reusable configuration.\n *\n * @example Standard usage\n * ```typescript\n * export const createUser = withTracing({\n *   name: 'user.create'\n * })(ctx => async (data) => {\n *   ctx.setAttribute('user.id', data.id)\n *   return await db.users.create(data)\n * })\n * ```\n *\n * @example Composable\n * ```typescript\n * const trace = withTracing({ serviceName: 'user' })\n *\n * export const createUser = trace(ctx => async (data) => { })\n * export const updateUser = trace(ctx => async (id, data) => { })\n * ```\n *\n * @example With other middleware\n * ```typescript\n * export const createUser = compose(\n *   withAuth({ role: 'admin' }),\n *   withTracing({ name: 'user.create' }),\n *   withRateLimit({ max: 100 })\n * )(ctx => async (data) => { })\n * ```\n */\nexport function withTracing<\n  TArgs extends unknown[] = unknown[],\n  TReturn = unknown,\n>(\n  options: TracingOptions<TArgs, TReturn> = {},\n): (\n  fnFactory: (\n    ctx: TraceContext,\n  ) => (...args: TArgs) => TReturn | Promise<TReturn>,\n) => (...args: TArgs) => TReturn | Promise<TReturn> {\n  return (\n    fnFactory: (\n      ctx: TraceContext,\n    ) => (...args: TArgs) => TReturn | Promise<TReturn>,\n  ): WrappedFunction<TArgs, TReturn> =>\n    wrapFactoryWithTracing<TArgs, TReturn>(fnFactory, options);\n}\n\n/**\n * Approach 3: instrument() - Batch auto-instrumentation\n *\n * Instrument an entire module/object at once.\n * Closest to @Instrumented decorator pattern.\n *\n * @example Basic usage\n * ```typescript\n * export default instrument({\n *   functions: {\n *     createUser: async (data) => { },\n *     updateUser: async (id, data) => { },\n *     deleteUser: async (id) => { }\n *   },\n *   serviceName: 'user',\n *   sampler: new AdaptiveSampler()\n * })\n * // → Traced as \"user.createUser\", \"user.updateUser\", \"user.deleteUser\"\n * ```\n *\n * @example Per-function overrides\n * ```typescript\n * export default instrument({\n *   functions: {\n *     createUser: async (data) => { },\n *     deleteUser: async (id) => { }\n *   },\n *   serviceName: 'user',\n *   overrides: {\n *     deleteUser: {\n *       sampler: new AlwaysSampler(),\n *       withMetrics: true\n *     }\n *   }\n * })\n * ```\n *\n * @example Skip functions\n * ```typescript\n * export default instrument({\n *   functions: {\n *     createUser: async (data) => { },\n *     _internal: async () => { }, // Auto-skipped (_-prefix)\n *     deleteUser: async (id) => { }\n *   },\n *   serviceName: 'user',\n *   skip: [/^test/, (key) => key.includes('debug')]\n * })\n * ```\n */\nexport function instrument<T extends Record<string, InstrumentableFunction>>(\n  options: InstrumentOptions<T>,\n): T {\n  const { functions, ...tracingOptions } = options;\n  const instrumented: Partial<T> = {};\n\n  for (const key of Object.keys(functions)) {\n    const typedKey = key as keyof T;\n    const fn = functions[typedKey];\n\n    // Skip if not a function or undefined - just pass through the value\n    if (!fn || typeof fn !== 'function') {\n      instrumented[typedKey] = fn as T[typeof typedKey];\n      continue;\n    }\n\n    // Only instrument own enumerable async functions\n    // Check if should skip\n    if (shouldSkip(key, fn, tracingOptions.skip)) {\n      instrumented[typedKey] = fn as T[typeof typedKey];\n      continue;\n    }\n\n    // Merge base options with per-function overrides\n    const fnOptions: TracingOptions = {\n      ...tracingOptions,\n      ...tracingOptions.overrides?.[key],\n      // If no explicit name, use key as function name\n      name: tracingOptions.overrides?.[key]?.name,\n    };\n\n    // Bind function to original object to preserve 'this' context\n    // This ensures methods can access state on the original object\n    const boundFn = fn.bind(functions);\n\n    // Convert plain function to factory pattern for trace()\n    // For instrument(), we create a factory that ignores ctx and returns the original function\n    const fnFactory = (ctx: TraceContext) => {\n      void ctx;\n      return boundFn;\n    };\n\n    // Wrap with tracing (sync or async based on implementation)\n    instrumented[typedKey] = wrapFactoryWithTracing(\n      fnFactory,\n      fnOptions,\n      key,\n    ) as T[typeof typedKey];\n  }\n\n  return instrumented as T;\n}\n\n/**\n * Options for span() function\n */\nexport interface SpanOptions {\n  /** Span name */\n  name: string;\n  /** Attributes to set on the span */\n  attributes?: Record<string, string | number | boolean>;\n}\n\n/**\n * Execute a function within a named span\n *\n * Useful for adding tracing to specific code blocks without wrapping\n * the entire function. Supports both synchronous and asynchronous functions.\n *\n * @example\n * ```typescript\n * // Async function\n * async function processOrder(order: Order) {\n *   await span({\n *     name: 'payment.charge',\n *     attributes: { amount: order.total }\n *   }, async (span) => {\n *     await chargeCustomer(order);\n *   })\n * }\n *\n * // Sync function\n * function calculateTotal(items: Item[]) {\n *   return span({\n *     name: 'calculateTotal',\n *     attributes: { itemCount: items.length }\n *   }, (span) => {\n *     return items.reduce((sum, item) => sum + item.price, 0);\n *   })\n * }\n * ```\n */\n// Overload for sync functions (more specific - should come first)\nexport function span<T = unknown>(\n  options: SpanOptions,\n  fn: (span: Span) => T,\n): T;\n// Overload for async functions\nexport function span<T = unknown>(\n  options: SpanOptions,\n  fn: (span: Span) => Promise<T>,\n): Promise<T>;\n// Implementation\nexport function span<T = unknown>(\n  options: SpanOptions,\n  fn: (span: Span) => T | Promise<T>,\n): T | Promise<T> {\n  const config = getConfig();\n  const tracer = config.tracer;\n  const { name, attributes } = options;\n\n  const executeSpan = (span: Span) => {\n    // Run within operation context so events can auto-capture operation.name\n    return runInOperationContext(name, () => {\n      try {\n        // Set attributes\n        if (attributes) {\n          for (const [key, value] of Object.entries(attributes)) {\n            span.setAttribute(key, value);\n          }\n        }\n\n        const result = fn(span);\n\n        // Check if result is a Promise\n        if (result instanceof Promise) {\n          return result\n            .then((resolved) => {\n              span.setStatus({ code: SpanStatusCode.OK });\n              span.end();\n              return resolved;\n            })\n            .catch((error) => {\n              const errorMessage =\n                error instanceof Error\n                  ? error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH)\n                  : String(error).slice(0, MAX_ERROR_MESSAGE_LENGTH);\n\n              span.setAttribute('error.message', errorMessage);\n              span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: errorMessage,\n              });\n\n              span.recordException(\n                error instanceof Error ? error : new Error(String(error)),\n              );\n              span.end();\n              throw error;\n            });\n        } else {\n          // Synchronous function\n          span.setStatus({ code: SpanStatusCode.OK });\n          span.end();\n          return result;\n        }\n      } catch (error) {\n        // Synchronous error handling\n        const errorMessage =\n          error instanceof Error\n            ? error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH)\n            : String(error).slice(0, MAX_ERROR_MESSAGE_LENGTH);\n\n        span.setAttribute('error.message', errorMessage);\n        span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: errorMessage,\n        });\n\n        span.recordException(\n          error instanceof Error ? error : new Error(String(error)),\n        );\n        span.end();\n        throw error;\n      }\n    });\n  };\n\n  const result = tracer.startActiveSpan(name, executeSpan);\n\n  // tracer.startActiveSpan might return a Promise even for sync callbacks\n  // Check if it's a Promise and handle accordingly\n  if (result instanceof Promise) {\n    return result;\n  }\n\n  return result as T;\n}\n\n/**\n * Options for withNewContext() function\n */\nexport interface WithNewContextOptions<T = unknown> {\n  /** Function to execute in new root context */\n  fn: () => Promise<T>;\n}\n\n/**\n * Execute a function in a new root context (prevents span propagation)\n *\n * Useful when you want to start a completely new trace without\n * parent-child relationships.\n *\n * @example\n * ```typescript\n * async function handleWebhook(payload: WebhookPayload) {\n *   // This creates a new root trace, not connected to the HTTP request trace\n *   await withNewContext({\n *     fn: async () => {\n *       await trace(ctx => async () => {\n *         await processWebhookPayload(payload)\n *       })()\n *     }\n *   })\n * }\n * ```\n */\nexport async function withNewContext<T = unknown>(\n  options: WithNewContextOptions<T>,\n): Promise<T> {\n  const { fn } = options;\n  const config = getConfig();\n  const tracer = config.tracer;\n\n  // Start a new root span (breaks trace propagation)\n  return tracer.startActiveSpan('root', { root: true }, async (span) => {\n    try {\n      const result = await fn();\n      span.setStatus({ code: SpanStatusCode.OK });\n      return result;\n    } catch (error) {\n      span.recordException(\n        error instanceof Error ? error : new Error(String(error)),\n      );\n      span.setStatus({ code: SpanStatusCode.ERROR });\n      throw error;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n/**\n * Options for withBaggage() function\n */\nexport interface WithBaggageOptions<T = unknown> {\n  /** Baggage entries to set (key-value pairs) */\n  baggage: Record<string, string>;\n  /** Function to execute with the updated baggage */\n  fn: () => T | Promise<T>;\n}\n\n/**\n * Execute a function with updated baggage entries\n *\n * Baggage is immutable in OpenTelemetry, so this helper creates a new context\n * with the specified baggage entries and runs the function within that context.\n * All child spans created within the function will inherit the baggage.\n *\n * @example Setting baggage for downstream services\n * ```typescript\n * import { trace, withBaggage } from 'autotel';\n *\n * export const createOrder = trace((ctx) => async (order: Order) => {\n *   // Set baggage that will be propagated to downstream HTTP calls\n *   return await withBaggage({\n *     baggage: {\n *       'tenant.id': order.tenantId,\n *       'user.id': order.userId,\n *     },\n *     fn: async () => {\n *       // This HTTP call will include the baggage in headers\n *       await fetch('/api/charge', {\n *         method: 'POST',\n *         body: JSON.stringify(order),\n *       });\n *     },\n *   });\n * });\n * ```\n *\n * @example Using with existing baggage\n * ```typescript\n * export const processOrder = trace((ctx) => async (order: Order) => {\n *   // Read existing baggage\n *   const tenantId = ctx.getBaggage('tenant.id');\n *\n *   // Add additional baggage entries\n *   return await withBaggage({\n *     baggage: {\n *       'order.id': order.id,\n *       'order.amount': String(order.amount),\n *     },\n *     fn: async () => {\n *       await charge(order);\n *     },\n *   });\n * });\n * ```\n */\nexport function withBaggage<T = unknown>(\n  options: WithBaggageOptions<T>,\n): T | Promise<T> {\n  const { baggage: baggageEntries, fn } = options;\n  const currentContext = context.active();\n\n  // Get existing baggage or create new\n  let updatedBaggage =\n    propagation.getBaggage(currentContext) ?? propagation.createBaggage();\n\n  // Set all baggage entries\n  for (const [key, value] of Object.entries(baggageEntries)) {\n    updatedBaggage = updatedBaggage.setEntry(key, { value });\n  }\n\n  // Create new context with updated baggage\n  const newContext = propagation.setBaggage(currentContext, updatedBaggage);\n\n  // Sync contextStorage so nested traces (via getActiveContextWithBaggage) see the baggage.\n  // Use run() instead of enterWith() to properly scope the context changes.\n  const ctxStorage = getContextStorage();\n  const previousStored = ctxStorage.getStore();\n  const baggageEnrichedStored = previousStored\n    ? propagation.setBaggage(previousStored, updatedBaggage)\n    : newContext;\n\n  // Run the function within the new context, scoped properly\n  const result = previousStored\n    ? ctxStorage.run(baggageEnrichedStored, () => context.with(newContext, fn))\n    : context.with(newContext, fn);\n\n  if (result instanceof Promise) {\n    // For async operations, ensure context is restored after the promise settles\n    return result.then(\n      (value) => {\n        // Restore original context before resolving\n        if (previousStored) {\n          return ctxStorage.run(previousStored, () => value);\n        }\n        return value;\n      },\n      (error) => {\n        // Restore original context before rejecting\n        if (previousStored) {\n          return ctxStorage.run(previousStored, () => {\n            throw error;\n          });\n        }\n        throw error;\n      },\n    );\n  }\n\n  // Sync function - context automatically restored when scope exits\n  return result;\n}\n"]}