autotel 6.0.0 → 6.2.0

package/dist/trace-helpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace-helpers.cjs","names":["trace","requireModule","context","SpanStatusCode"],"sources":["../src/trace-helpers.ts"],"sourcesContent":["/**\n * Trace context helpers - Core primitives for trace correlation\n *\n * These are the building blocks that allow users to bring their own logger\n * (bunyan, log4js, custom, etc.) and add trace correlation.\n *\n * @example Using with bunyan\n * ```typescript\n * import bunyan from 'bunyan';\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n *\n * const logger = {\n *   info: (msg: string, extra?: object) => {\n *     bunyanLogger.info(enrichWithTraceContext(extra || {}), msg);\n *   }\n * };\n * ```\n *\n * @example Using with log4js\n * ```typescript\n * import log4js from 'log4js';\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const log4jsLogger = log4js.getLogger();\n *\n * function logWithTrace(level: string, msg: string, extra?: object) {\n *   const context = getTraceContext();\n *   log4jsLogger[level](msg, { ...extra, ...context });\n * }\n * ```\n */\n\nimport { trace, context, SpanStatusCode } from '@opentelemetry/api';\nimport type { Span, Tracer, Context } from '@opentelemetry/api';\nimport { requireModule } from './node-require';\n\n/**\n * WeakMap to store span names for active spans\n * This allows us to retrieve the span name even though OpenTelemetry\n * doesn't expose it through the public API\n */\nconst spanNameMap = new WeakMap<Span, string>();\n\n/**\n * Store span name for a given span\n * Called internally when spans are created\n */\nexport function setSpanName(span: Span, name: string): void {\n  spanNameMap.set(span, name);\n}\n\n/**\n * Trace context extracted from active span\n */\nexport interface TraceContext {\n  /** Full 32-character hex trace ID */\n  traceId: string;\n  /** 16-character hex span ID */\n  spanId: string;\n  /** First 16 characters of trace ID (for log grouping/correlation) */\n  correlationId: string;\n  /** Function/operation name (OpenTelemetry semantic convention: code.function) */\n  'code.function'?: string;\n  /** Datadog trace ID in decimal format (lower 64 bits) for log-trace correlation */\n  'dd.trace_id'?: string;\n  /** Datadog span ID in decimal format for log-trace correlation */\n  'dd.span_id'?: string;\n}\n\n/**\n * Convert hex string to decimal string representation\n * Handles 64-bit unsigned integers for Datadog correlation\n *\n * @param hex - Hex string (up to 16 characters for 64-bit)\n * @returns Decimal string representation\n */\nfunction hexToDecimal(hex: string): string {\n  // For 64-bit values, use BigInt to avoid precision loss\n  return BigInt('0x' + hex).toString(10);\n}\n\n/**\n * Get current trace context from active span\n *\n * Returns null if no span is active (e.g., outside of trace operation)\n *\n * Includes both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility.\n *\n * @returns Trace context with traceId, spanId, correlationId, and Datadog decimal IDs, or null\n *\n * @example\n * ```typescript\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const context = getTraceContext();\n * if (context) {\n *   console.log('Current trace:', context.traceId);\n *   // Current trace: 4bf92f3577b34da6a3ce929d0e0e4736\n *   console.log('Datadog trace ID:', context['dd.trace_id']);\n *   // Datadog trace ID: 12007117331170166582 (decimal for log correlation)\n * }\n * ```\n */\nexport function getTraceContext(): TraceContext | null {\n  const span = trace.getActiveSpan();\n  if (!span) return null;\n\n  const spanContext = span.spanContext();\n  const traceId = spanContext.traceId;\n  const spanId = spanContext.spanId;\n\n  // Get span name from WeakMap (set when span is created)\n  // Map to OpenTelemetry semantic convention: code.function\n  const spanName = spanNameMap.get(span);\n\n  // Datadog uses the lower 64 bits of the 128-bit OpenTelemetry trace ID\n  // Convert from hex to decimal for Datadog's log-trace correlation\n  const traceIdLower64 = traceId.slice(-16); // Last 16 hex chars = lower 64 bits\n  const ddTraceId = hexToDecimal(traceIdLower64);\n  const ddSpanId = hexToDecimal(spanId);\n\n  return {\n    traceId,\n    spanId,\n    correlationId: traceId.slice(0, 16),\n    ...(spanName && { 'code.function': spanName }),\n    // Datadog-specific fields for log-trace correlation\n    'dd.trace_id': ddTraceId,\n    'dd.span_id': ddSpanId,\n  };\n}\n\n/**\n * Enrich object with trace context (traceId, spanId, correlationId, and Datadog fields)\n *\n * If no span is active, returns the object unchanged.\n * This prevents \"undefined\" or \"null\" values in logs.\n *\n * Automatically adds both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility with observability backends.\n *\n * @param obj - Object to enrich (e.g., log metadata)\n * @returns Object with trace context merged in, or unchanged if no active span\n *\n * @example\n * ```typescript\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * // Inside a trace operation:\n * const enriched = enrichWithTraceContext({ userId: '123' });\n * // {\n * //   userId: '123',\n * //   traceId: '4bf92f3577b34da6a3ce929d0e0e4736',\n * //   spanId: '00f067aa0ba902b7',\n * //   correlationId: '4bf92f3577b34da6',\n * //   'dd.trace_id': '12007117331170166582',  // Datadog decimal format\n * //   'dd.span_id': '67667974448284583'       // Datadog decimal format\n * // }\n *\n * // Outside trace operation:\n * const unchanged = enrichWithTraceContext({ userId: '123' });\n * // { userId: '123' } - no trace fields added\n * ```\n */\nexport function enrichWithTraceContext<T extends Record<string, unknown>>(\n  obj: T,\n): T {\n  const context = getTraceContext();\n  return context ? ({ ...obj, ...context } as T) : obj;\n}\n\n/**\n * Check if currently in a trace context\n *\n * Useful for conditional logic based on trace presence\n *\n * @returns true if active span exists, false otherwise\n *\n * @example\n * ```typescript\n * import { isTracing } from 'autotel/trace-helpers';\n *\n * if (isTracing()) {\n *   // Add expensive debug metadata only when tracing\n *   logger.debug('Detailed context', expensiveDebugData());\n * }\n * ```\n */\nexport function isTracing(): boolean {\n  return trace.getActiveSpan() !== undefined;\n}\n\n/**\n * Get a tracer instance for creating custom spans\n *\n * Use this when you need low-level control over span lifecycle.\n * For most use cases, prefer trace(), span(), or instrument() instead.\n *\n * @param name - Tracer name (usually your service or module name)\n * @param version - Optional version string\n * @returns OpenTelemetry Tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getTracer } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('custom.operation');\n * try {\n *   // Your logic\n *   span.setAttribute('key', 'value');\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example With AI SDK\n * ```typescript\n * import { getTracer } from 'autotel';\n * import { generateText } from 'ai';\n *\n * const tracer = getTracer('ai-agent');\n * const result = await generateText({\n *   model: myModel,\n *   prompt: 'Hello',\n *   experimental_telemetry: {\n *     isEnabled: true,\n *     tracer,\n *   },\n * });\n * ```\n */\nexport function getTracer(name: string, version?: string): Tracer {\n  return trace.getTracer(name, version);\n}\n\n/**\n * Get the currently active span\n *\n * Returns undefined if no span is currently active.\n * Useful for adding attributes to the current span.\n *\n * @returns Active span or undefined\n *\n * @example Adding attributes to active span\n * ```typescript\n * import { getActiveSpan } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span) {\n *   span.setAttribute('user.id', userId);\n *   span.setAttribute('user.action', 'click');\n * }\n * ```\n *\n * @example Checking span status\n * ```typescript\n * import { getActiveSpan, SpanStatusCode } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span?.isRecording()) {\n *   span.setStatus({ code: SpanStatusCode.OK });\n * }\n * ```\n */\nexport function getActiveSpan(): Span | undefined {\n  return trace.getActiveSpan();\n}\n\n/**\n * Get the currently active OpenTelemetry context\n *\n * The context contains the active span and any baggage.\n * Useful for context propagation and custom instrumentation.\n *\n * @returns Current active context\n *\n * @example Propagating context\n * ```typescript\n * import { getActiveContext } from 'autotel';\n *\n * const currentContext = getActiveContext();\n * // Pass context to another function or service\n * ```\n *\n * @example With context injection\n * ```typescript\n * import { getActiveContext, injectTraceContext } from 'autotel';\n *\n * const headers = {};\n * injectTraceContext(headers);\n * // Headers now contain trace propagation data\n * ```\n */\nexport function getActiveContext(): Context {\n  // Check stored context first (from baggage setters), then fall back to active context\n  // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations\n  try {\n    const { getActiveContextWithBaggage } = requireModule<{\n      getActiveContextWithBaggage: () => Context;\n    }>('./trace-context');\n    return getActiveContextWithBaggage();\n  } catch {\n    // Fallback if trace-context isn't available\n    return context.active();\n  }\n}\n\n/**\n * Run a function with a specific span set as active\n *\n * This is a convenience wrapper around the two-step process of\n * setting a span in context and running code within that context.\n *\n * @param span - The span to set as active\n * @param fn - Function to execute with the span active\n * @returns The return value of the function\n *\n * @example Running code with a custom span\n * ```typescript\n * import { getTracer, runWithSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('background.job');\n *\n * try {\n *   const result = await runWithSpan(span, async () => {\n *     // Any spans created here will be children of 'background.job'\n *     await processData();\n *     return { success: true };\n *   });\n *   console.log(result);\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example Testing with custom spans\n * ```typescript\n * import { runWithSpan, otelTrace } from 'autotel';\n *\n * const tracer = otelTrace.getTracer('test');\n * const span = tracer.startSpan('test.operation');\n *\n * const result = runWithSpan(span, () => {\n *   // Code under test runs with this span as active\n *   return myFunction();\n * });\n *\n * span.end();\n * ```\n */\nexport function runWithSpan<T>(span: Span, fn: () => T): T {\n  const ctx = trace.setSpan(context.active(), span);\n  return context.with(ctx, fn);\n}\n\n/**\n * Finalize a span with appropriate status and optional error recording\n *\n * This is a convenience function that:\n * - Records exceptions if an error is provided\n * - Sets span status to ERROR if error exists, OK otherwise\n * - Ends the span\n *\n * @param span - The span to finalize\n * @param error - Optional error to record\n *\n * @example Without error (success case)\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await doWork();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error);\n *   throw error;\n * }\n * ```\n *\n * @example With error\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await riskyOperation();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error); // Records exception and sets ERROR status\n *   throw error;\n * }\n * ```\n *\n * @example In instrumentation\n * ```typescript\n * import { getTracer, runWithSpan, finalizeSpan } from 'autotel';\n *\n * function instrumentedQuery(query: string) {\n *   const tracer = getTracer('db');\n *   const span = tracer.startSpan('db.query');\n *\n *   return runWithSpan(span, () => {\n *     try {\n *       const result = executeQuery(query);\n *       finalizeSpan(span);\n *       return result;\n *     } catch (error) {\n *       finalizeSpan(span, error);\n *       throw error;\n *     }\n *   });\n * }\n * ```\n */\nexport function finalizeSpan(span: Span, error?: unknown): void {\n  if (error) {\n    if (error instanceof Error) {\n      span.recordException(error);\n    } else {\n      span.recordException(new Error(String(error)));\n    }\n    span.setStatus({ code: SpanStatusCode.ERROR });\n  } else {\n    span.setStatus({ code: SpanStatusCode.OK });\n  }\n  span.end();\n}\n\n/**\n * Creates a deterministic trace ID from a seed string.\n *\n * Generates a consistent 128-bit trace ID (32 hex characters) from an input seed\n * using SHA-256 hashing. Useful for correlating external system IDs (request IDs,\n * order IDs, session IDs) with OpenTelemetry trace IDs.\n *\n * **Use Cases:**\n * - Correlate external request IDs with traces\n * - Link customer support tickets to trace data\n * - Associate business entities (orders, sessions) with observability data\n * - Debug specific user flows by deterministic trace lookup\n *\n * **Important:** Only use this when you need deterministic trace IDs for correlation.\n * For normal tracing, let OpenTelemetry generate random trace IDs automatically.\n *\n * **Runtime Support:**\n * - Node.js 15+ (native crypto.subtle)\n * - All modern browsers\n * - Edge runtimes (Cloudflare Workers, Deno, etc.)\n *\n * @param seed - Input string to generate trace ID from (e.g., request ID, order ID)\n * @returns Promise resolving to a 32-character hex trace ID (128 bits)\n *\n * @example Correlate external request ID with trace\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n * import { trace, context } from '@opentelemetry/api'\n *\n * // In middleware or request handler\n * const requestId = req.headers['x-request-id']\n * const traceId = await createDeterministicTraceId(requestId)\n *\n * // Use with manual span creation (advanced - not needed with trace/span functions)\n * const tracer = trace.getTracer('my-service')\n * const spanContext = {\n *   traceId,\n *   spanId: '0123456789abcdef', // Still random\n *   traceFlags: 1\n * }\n * ```\n *\n * @example Link customer support tickets to traces\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Support dashboard integration\n * const ticketId = 'TICKET-12345'\n * const traceId = await createDeterministicTraceId(ticketId)\n *\n * // Generate direct link to traces in observability backend\n * const traceUrl = `https://your-otel-backend.com/traces/${traceId}`\n * console.log(`View related traces: ${traceUrl}`)\n * ```\n *\n * @example Session-based correlation\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Track all operations for a user session\n * const sessionId = req.session.id\n * const traceId = await createDeterministicTraceId(sessionId)\n *\n * // All operations in this session share the same trace ID\n * // Makes it easy to find all activity for a specific session\n * ```\n *\n * @public\n */\nexport async function createDeterministicTraceId(\n  seed: string,\n): Promise<string> {\n  // Encode seed string to bytes\n  const encoder = new TextEncoder();\n  const data = encoder.encode(seed);\n\n  // Generate SHA-256 hash (256 bits)\n  const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n\n  // Convert to hex string and truncate to 32 characters (128 bits)\n  // OpenTelemetry trace IDs are 128 bits (16 bytes, 32 hex characters)\n  const hashArray = new Uint8Array(hashBuffer);\n  return [...hashArray]\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('')\n    .slice(0, 32);\n}\n\n/**\n * Flattens nested metadata objects into dot-notation span attributes.\n *\n * Converts complex nested objects into flat key-value pairs suitable for\n * OpenTelemetry span attributes. Non-string values are JSON serialized.\n * Handles serialization failures gracefully with a fallback value.\n *\n * **Use Cases:**\n * - Structured metadata with nested objects\n * - User context with multiple properties\n * - Request/response metadata\n * - Business entity attributes\n *\n * **Note:** Filters out null/undefined values automatically to keep spans clean.\n *\n * @param metadata - Nested metadata object to flatten\n * @param prefix - Prefix for all attribute keys (default: 'metadata')\n * @returns Flattened attributes as { [key: string]: string }\n *\n * @example Basic metadata flattening\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const processOrder = withTracing({})(ctx => async (orderId: string) => {\n *   const order = await getOrder(orderId)\n *\n *   // Flatten complex order metadata\n *   const flattened = flattenMetadata({\n *     user: { id: order.userId, tier: 'premium' },\n *     payment: { method: 'card', processor: 'stripe' },\n *     items: order.items.length\n *   })\n *\n *   ctx.setAttributes(flattened)\n *   // Results in:\n *   // {\n *   //   'metadata.user.id': 'user-123',\n *   //   'metadata.user.tier': 'premium',\n *   //   'metadata.payment.method': 'card',\n *   //   'metadata.payment.processor': 'stripe',\n *   //   'metadata.items': '5'\n *   // }\n * })\n * ```\n *\n * @example Custom prefix for semantic conventions\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const fetchUser = withTracing({})(ctx => async (userId: string) => {\n *   const user = await db.users.findOne({ id: userId })\n *\n *   // Use semantic convention prefix\n *   const userAttrs = flattenMetadata(\n *     {\n *       id: user.id,\n *       email: user.email,\n *       plan: user.subscription.plan\n *     },\n *     'user'  // Custom prefix\n *   )\n *\n *   ctx.setAttributes(userAttrs)\n *   // Results in:\n *   // {\n *   //   'user.id': 'user-123',\n *   //   'user.email': 'user@example.com',\n *   //   'user.plan': 'enterprise'\n *   // }\n * })\n * ```\n *\n * @example With complex objects (auto-serialized)\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const analyzeRequest = withTracing({})(ctx => async (req: Request) => {\n *   const metadata = flattenMetadata({\n *     headers: req.headers,  // Object - will be JSON serialized\n *     query: req.query,       // Object - will be JSON serialized\n *     timestamp: new Date()   // Non-string - will be JSON serialized\n *   })\n *\n *   ctx.setAttributes(metadata)\n *   // Results in:\n *   // {\n *   //   'metadata.headers': '{\"accept\":\"application/json\",...}',\n *   //   'metadata.query': '{\"page\":\"1\",\"limit\":\"10\"}',\n *   //   'metadata.timestamp': '\"2024-01-15T12:00:00.000Z\"'\n *   // }\n * })\n * ```\n *\n * @example Error handling\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n *\n * // Objects with circular references are handled gracefully\n * const circular: any = { a: 1 }\n * circular.self = circular\n *\n * const flattened = flattenMetadata({ data: circular })\n * // Results in:\n * // { 'metadata.data': '<serialization-failed>' }\n * ```\n *\n * @public\n */\n/**\n * Resolve a trace URL from a template string and trace ID.\n *\n * Templates use `{traceId}` as placeholder. Falls back to `OTEL_TRACE_URL_TEMPLATE` env var.\n *\n * @example\n * resolveTraceUrl('https://grafana.example.com/explore?traceId={traceId}', 'abc123')\n * // => 'https://grafana.example.com/explore?traceId=abc123'\n */\nexport function resolveTraceUrl(\n  template: string | undefined,\n  traceId: string,\n): string | undefined {\n  const t = template ?? process.env.OTEL_TRACE_URL_TEMPLATE;\n  if (!t) return undefined;\n  return t.replaceAll('{traceId}', traceId);\n}\n\nexport function flattenMetadata(\n  metadata: Record<string, unknown>,\n  prefix = 'metadata',\n): Record<string, string> {\n  const flattened: Record<string, string> = {};\n  const seen = new WeakSet<object>(); // Track visited objects to detect cycles\n\n  function flatten(obj: Record<string, unknown>, currentPrefix: string): void {\n    for (const [key, value] of Object.entries(obj)) {\n      // Skip null/undefined values\n      if (value == null) continue;\n\n      const attributeKey = `${currentPrefix}.${key}`;\n\n      // Handle primitives directly (string, number, boolean)\n      if (typeof value === 'string') {\n        flattened[attributeKey] = value;\n        continue;\n      }\n      if (typeof value === 'number' || typeof value === 'boolean') {\n        flattened[attributeKey] = String(value);\n        continue;\n      }\n\n      // Recursively flatten plain objects (with cycle detection)\n      if (\n        typeof value === 'object' &&\n        value !== null &&\n        value.constructor === Object\n      ) {\n        // Detect circular references\n        if (seen.has(value)) {\n          flattened[attributeKey] = '<circular-reference>';\n          continue;\n        }\n\n        // Mark as visited and recursively flatten\n        seen.add(value);\n        flatten(value as Record<string, unknown>, attributeKey);\n        continue;\n      }\n\n      // Serialize arrays and other non-plain objects to JSON\n      try {\n        flattened[attributeKey] = JSON.stringify(value);\n      } catch {\n        // Handle circular references or non-serializable objects\n        flattened[attributeKey] = '<serialization-failed>';\n      }\n    }\n  }\n\n  flatten(metadata, prefix);\n  return flattened;\n}\n"],"mappings":"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"}

package/dist/trace-helpers.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace-helpers.d.cts","names":[],"sources":["../src/trace-helpers.ts"],"mappings":";;;;;;iBAiDgB,YAAY,MAAM,MAAM;;;;UAOvB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCc,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnB,uBAAuB,UAAU,yBAC/C,KAAK,IACJ;;;;;;;;;;;;;;;;;;iBAsBa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CA,UAAU,cAAc,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiC3C,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BjB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DpB,YAAY,GAAG,MAAM,MAAM,UAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqEzC,aAAa,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFnB,2BACpB,eACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyIa,gBACd,8BACA;iBAOc,gBACd,UAAU,yBACV,kBACC"}

package/dist/trace-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace-helpers.d.ts","names":[],"sources":["../src/trace-helpers.ts"],"mappings":";;;;;;iBAiDgB,YAAY,MAAM,MAAM;;;;UAOvB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCc,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnB,uBAAuB,UAAU,yBAC/C,KAAK,IACJ;;;;;;;;;;;;;;;;;;iBAsBa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CA,UAAU,cAAc,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiC3C,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BjB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DpB,YAAY,GAAG,MAAM,MAAM,UAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqEzC,aAAa,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFnB,2BACpB,eACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyIa,gBACd,8BACA;iBAOc,gBACd,UAAU,yBACV,kBACC"}

package/dist/trace-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace-helpers.js","names":[],"sources":["../src/trace-helpers.ts"],"sourcesContent":["/**\n * Trace context helpers - Core primitives for trace correlation\n *\n * These are the building blocks that allow users to bring their own logger\n * (bunyan, log4js, custom, etc.) and add trace correlation.\n *\n * @example Using with bunyan\n * ```typescript\n * import bunyan from 'bunyan';\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n *\n * const logger = {\n *   info: (msg: string, extra?: object) => {\n *     bunyanLogger.info(enrichWithTraceContext(extra || {}), msg);\n *   }\n * };\n * ```\n *\n * @example Using with log4js\n * ```typescript\n * import log4js from 'log4js';\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const log4jsLogger = log4js.getLogger();\n *\n * function logWithTrace(level: string, msg: string, extra?: object) {\n *   const context = getTraceContext();\n *   log4jsLogger[level](msg, { ...extra, ...context });\n * }\n * ```\n */\n\nimport { trace, context, SpanStatusCode } from '@opentelemetry/api';\nimport type { Span, Tracer, Context } from '@opentelemetry/api';\nimport { requireModule } from './node-require';\n\n/**\n * WeakMap to store span names for active spans\n * This allows us to retrieve the span name even though OpenTelemetry\n * doesn't expose it through the public API\n */\nconst spanNameMap = new WeakMap<Span, string>();\n\n/**\n * Store span name for a given span\n * Called internally when spans are created\n */\nexport function setSpanName(span: Span, name: string): void {\n  spanNameMap.set(span, name);\n}\n\n/**\n * Trace context extracted from active span\n */\nexport interface TraceContext {\n  /** Full 32-character hex trace ID */\n  traceId: string;\n  /** 16-character hex span ID */\n  spanId: string;\n  /** First 16 characters of trace ID (for log grouping/correlation) */\n  correlationId: string;\n  /** Function/operation name (OpenTelemetry semantic convention: code.function) */\n  'code.function'?: string;\n  /** Datadog trace ID in decimal format (lower 64 bits) for log-trace correlation */\n  'dd.trace_id'?: string;\n  /** Datadog span ID in decimal format for log-trace correlation */\n  'dd.span_id'?: string;\n}\n\n/**\n * Convert hex string to decimal string representation\n * Handles 64-bit unsigned integers for Datadog correlation\n *\n * @param hex - Hex string (up to 16 characters for 64-bit)\n * @returns Decimal string representation\n */\nfunction hexToDecimal(hex: string): string {\n  // For 64-bit values, use BigInt to avoid precision loss\n  return BigInt('0x' + hex).toString(10);\n}\n\n/**\n * Get current trace context from active span\n *\n * Returns null if no span is active (e.g., outside of trace operation)\n *\n * Includes both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility.\n *\n * @returns Trace context with traceId, spanId, correlationId, and Datadog decimal IDs, or null\n *\n * @example\n * ```typescript\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const context = getTraceContext();\n * if (context) {\n *   console.log('Current trace:', context.traceId);\n *   // Current trace: 4bf92f3577b34da6a3ce929d0e0e4736\n *   console.log('Datadog trace ID:', context['dd.trace_id']);\n *   // Datadog trace ID: 12007117331170166582 (decimal for log correlation)\n * }\n * ```\n */\nexport function getTraceContext(): TraceContext | null {\n  const span = trace.getActiveSpan();\n  if (!span) return null;\n\n  const spanContext = span.spanContext();\n  const traceId = spanContext.traceId;\n  const spanId = spanContext.spanId;\n\n  // Get span name from WeakMap (set when span is created)\n  // Map to OpenTelemetry semantic convention: code.function\n  const spanName = spanNameMap.get(span);\n\n  // Datadog uses the lower 64 bits of the 128-bit OpenTelemetry trace ID\n  // Convert from hex to decimal for Datadog's log-trace correlation\n  const traceIdLower64 = traceId.slice(-16); // Last 16 hex chars = lower 64 bits\n  const ddTraceId = hexToDecimal(traceIdLower64);\n  const ddSpanId = hexToDecimal(spanId);\n\n  return {\n    traceId,\n    spanId,\n    correlationId: traceId.slice(0, 16),\n    ...(spanName && { 'code.function': spanName }),\n    // Datadog-specific fields for log-trace correlation\n    'dd.trace_id': ddTraceId,\n    'dd.span_id': ddSpanId,\n  };\n}\n\n/**\n * Enrich object with trace context (traceId, spanId, correlationId, and Datadog fields)\n *\n * If no span is active, returns the object unchanged.\n * This prevents \"undefined\" or \"null\" values in logs.\n *\n * Automatically adds both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility with observability backends.\n *\n * @param obj - Object to enrich (e.g., log metadata)\n * @returns Object with trace context merged in, or unchanged if no active span\n *\n * @example\n * ```typescript\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * // Inside a trace operation:\n * const enriched = enrichWithTraceContext({ userId: '123' });\n * // {\n * //   userId: '123',\n * //   traceId: '4bf92f3577b34da6a3ce929d0e0e4736',\n * //   spanId: '00f067aa0ba902b7',\n * //   correlationId: '4bf92f3577b34da6',\n * //   'dd.trace_id': '12007117331170166582',  // Datadog decimal format\n * //   'dd.span_id': '67667974448284583'       // Datadog decimal format\n * // }\n *\n * // Outside trace operation:\n * const unchanged = enrichWithTraceContext({ userId: '123' });\n * // { userId: '123' } - no trace fields added\n * ```\n */\nexport function enrichWithTraceContext<T extends Record<string, unknown>>(\n  obj: T,\n): T {\n  const context = getTraceContext();\n  return context ? ({ ...obj, ...context } as T) : obj;\n}\n\n/**\n * Check if currently in a trace context\n *\n * Useful for conditional logic based on trace presence\n *\n * @returns true if active span exists, false otherwise\n *\n * @example\n * ```typescript\n * import { isTracing } from 'autotel/trace-helpers';\n *\n * if (isTracing()) {\n *   // Add expensive debug metadata only when tracing\n *   logger.debug('Detailed context', expensiveDebugData());\n * }\n * ```\n */\nexport function isTracing(): boolean {\n  return trace.getActiveSpan() !== undefined;\n}\n\n/**\n * Get a tracer instance for creating custom spans\n *\n * Use this when you need low-level control over span lifecycle.\n * For most use cases, prefer trace(), span(), or instrument() instead.\n *\n * @param name - Tracer name (usually your service or module name)\n * @param version - Optional version string\n * @returns OpenTelemetry Tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getTracer } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('custom.operation');\n * try {\n *   // Your logic\n *   span.setAttribute('key', 'value');\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example With AI SDK\n * ```typescript\n * import { getTracer } from 'autotel';\n * import { generateText } from 'ai';\n *\n * const tracer = getTracer('ai-agent');\n * const result = await generateText({\n *   model: myModel,\n *   prompt: 'Hello',\n *   experimental_telemetry: {\n *     isEnabled: true,\n *     tracer,\n *   },\n * });\n * ```\n */\nexport function getTracer(name: string, version?: string): Tracer {\n  return trace.getTracer(name, version);\n}\n\n/**\n * Get the currently active span\n *\n * Returns undefined if no span is currently active.\n * Useful for adding attributes to the current span.\n *\n * @returns Active span or undefined\n *\n * @example Adding attributes to active span\n * ```typescript\n * import { getActiveSpan } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span) {\n *   span.setAttribute('user.id', userId);\n *   span.setAttribute('user.action', 'click');\n * }\n * ```\n *\n * @example Checking span status\n * ```typescript\n * import { getActiveSpan, SpanStatusCode } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span?.isRecording()) {\n *   span.setStatus({ code: SpanStatusCode.OK });\n * }\n * ```\n */\nexport function getActiveSpan(): Span | undefined {\n  return trace.getActiveSpan();\n}\n\n/**\n * Get the currently active OpenTelemetry context\n *\n * The context contains the active span and any baggage.\n * Useful for context propagation and custom instrumentation.\n *\n * @returns Current active context\n *\n * @example Propagating context\n * ```typescript\n * import { getActiveContext } from 'autotel';\n *\n * const currentContext = getActiveContext();\n * // Pass context to another function or service\n * ```\n *\n * @example With context injection\n * ```typescript\n * import { getActiveContext, injectTraceContext } from 'autotel';\n *\n * const headers = {};\n * injectTraceContext(headers);\n * // Headers now contain trace propagation data\n * ```\n */\nexport function getActiveContext(): Context {\n  // Check stored context first (from baggage setters), then fall back to active context\n  // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations\n  try {\n    const { getActiveContextWithBaggage } = requireModule<{\n      getActiveContextWithBaggage: () => Context;\n    }>('./trace-context');\n    return getActiveContextWithBaggage();\n  } catch {\n    // Fallback if trace-context isn't available\n    return context.active();\n  }\n}\n\n/**\n * Run a function with a specific span set as active\n *\n * This is a convenience wrapper around the two-step process of\n * setting a span in context and running code within that context.\n *\n * @param span - The span to set as active\n * @param fn - Function to execute with the span active\n * @returns The return value of the function\n *\n * @example Running code with a custom span\n * ```typescript\n * import { getTracer, runWithSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('background.job');\n *\n * try {\n *   const result = await runWithSpan(span, async () => {\n *     // Any spans created here will be children of 'background.job'\n *     await processData();\n *     return { success: true };\n *   });\n *   console.log(result);\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example Testing with custom spans\n * ```typescript\n * import { runWithSpan, otelTrace } from 'autotel';\n *\n * const tracer = otelTrace.getTracer('test');\n * const span = tracer.startSpan('test.operation');\n *\n * const result = runWithSpan(span, () => {\n *   // Code under test runs with this span as active\n *   return myFunction();\n * });\n *\n * span.end();\n * ```\n */\nexport function runWithSpan<T>(span: Span, fn: () => T): T {\n  const ctx = trace.setSpan(context.active(), span);\n  return context.with(ctx, fn);\n}\n\n/**\n * Finalize a span with appropriate status and optional error recording\n *\n * This is a convenience function that:\n * - Records exceptions if an error is provided\n * - Sets span status to ERROR if error exists, OK otherwise\n * - Ends the span\n *\n * @param span - The span to finalize\n * @param error - Optional error to record\n *\n * @example Without error (success case)\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await doWork();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error);\n *   throw error;\n * }\n * ```\n *\n * @example With error\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await riskyOperation();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error); // Records exception and sets ERROR status\n *   throw error;\n * }\n * ```\n *\n * @example In instrumentation\n * ```typescript\n * import { getTracer, runWithSpan, finalizeSpan } from 'autotel';\n *\n * function instrumentedQuery(query: string) {\n *   const tracer = getTracer('db');\n *   const span = tracer.startSpan('db.query');\n *\n *   return runWithSpan(span, () => {\n *     try {\n *       const result = executeQuery(query);\n *       finalizeSpan(span);\n *       return result;\n *     } catch (error) {\n *       finalizeSpan(span, error);\n *       throw error;\n *     }\n *   });\n * }\n * ```\n */\nexport function finalizeSpan(span: Span, error?: unknown): void {\n  if (error) {\n    if (error instanceof Error) {\n      span.recordException(error);\n    } else {\n      span.recordException(new Error(String(error)));\n    }\n    span.setStatus({ code: SpanStatusCode.ERROR });\n  } else {\n    span.setStatus({ code: SpanStatusCode.OK });\n  }\n  span.end();\n}\n\n/**\n * Creates a deterministic trace ID from a seed string.\n *\n * Generates a consistent 128-bit trace ID (32 hex characters) from an input seed\n * using SHA-256 hashing. Useful for correlating external system IDs (request IDs,\n * order IDs, session IDs) with OpenTelemetry trace IDs.\n *\n * **Use Cases:**\n * - Correlate external request IDs with traces\n * - Link customer support tickets to trace data\n * - Associate business entities (orders, sessions) with observability data\n * - Debug specific user flows by deterministic trace lookup\n *\n * **Important:** Only use this when you need deterministic trace IDs for correlation.\n * For normal tracing, let OpenTelemetry generate random trace IDs automatically.\n *\n * **Runtime Support:**\n * - Node.js 15+ (native crypto.subtle)\n * - All modern browsers\n * - Edge runtimes (Cloudflare Workers, Deno, etc.)\n *\n * @param seed - Input string to generate trace ID from (e.g., request ID, order ID)\n * @returns Promise resolving to a 32-character hex trace ID (128 bits)\n *\n * @example Correlate external request ID with trace\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n * import { trace, context } from '@opentelemetry/api'\n *\n * // In middleware or request handler\n * const requestId = req.headers['x-request-id']\n * const traceId = await createDeterministicTraceId(requestId)\n *\n * // Use with manual span creation (advanced - not needed with trace/span functions)\n * const tracer = trace.getTracer('my-service')\n * const spanContext = {\n *   traceId,\n *   spanId: '0123456789abcdef', // Still random\n *   traceFlags: 1\n * }\n * ```\n *\n * @example Link customer support tickets to traces\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Support dashboard integration\n * const ticketId = 'TICKET-12345'\n * const traceId = await createDeterministicTraceId(ticketId)\n *\n * // Generate direct link to traces in observability backend\n * const traceUrl = `https://your-otel-backend.com/traces/${traceId}`\n * console.log(`View related traces: ${traceUrl}`)\n * ```\n *\n * @example Session-based correlation\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Track all operations for a user session\n * const sessionId = req.session.id\n * const traceId = await createDeterministicTraceId(sessionId)\n *\n * // All operations in this session share the same trace ID\n * // Makes it easy to find all activity for a specific session\n * ```\n *\n * @public\n */\nexport async function createDeterministicTraceId(\n  seed: string,\n): Promise<string> {\n  // Encode seed string to bytes\n  const encoder = new TextEncoder();\n  const data = encoder.encode(seed);\n\n  // Generate SHA-256 hash (256 bits)\n  const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n\n  // Convert to hex string and truncate to 32 characters (128 bits)\n  // OpenTelemetry trace IDs are 128 bits (16 bytes, 32 hex characters)\n  const hashArray = new Uint8Array(hashBuffer);\n  return [...hashArray]\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('')\n    .slice(0, 32);\n}\n\n/**\n * Flattens nested metadata objects into dot-notation span attributes.\n *\n * Converts complex nested objects into flat key-value pairs suitable for\n * OpenTelemetry span attributes. Non-string values are JSON serialized.\n * Handles serialization failures gracefully with a fallback value.\n *\n * **Use Cases:**\n * - Structured metadata with nested objects\n * - User context with multiple properties\n * - Request/response metadata\n * - Business entity attributes\n *\n * **Note:** Filters out null/undefined values automatically to keep spans clean.\n *\n * @param metadata - Nested metadata object to flatten\n * @param prefix - Prefix for all attribute keys (default: 'metadata')\n * @returns Flattened attributes as { [key: string]: string }\n *\n * @example Basic metadata flattening\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const processOrder = withTracing({})(ctx => async (orderId: string) => {\n *   const order = await getOrder(orderId)\n *\n *   // Flatten complex order metadata\n *   const flattened = flattenMetadata({\n *     user: { id: order.userId, tier: 'premium' },\n *     payment: { method: 'card', processor: 'stripe' },\n *     items: order.items.length\n *   })\n *\n *   ctx.setAttributes(flattened)\n *   // Results in:\n *   // {\n *   //   'metadata.user.id': 'user-123',\n *   //   'metadata.user.tier': 'premium',\n *   //   'metadata.payment.method': 'card',\n *   //   'metadata.payment.processor': 'stripe',\n *   //   'metadata.items': '5'\n *   // }\n * })\n * ```\n *\n * @example Custom prefix for semantic conventions\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const fetchUser = withTracing({})(ctx => async (userId: string) => {\n *   const user = await db.users.findOne({ id: userId })\n *\n *   // Use semantic convention prefix\n *   const userAttrs = flattenMetadata(\n *     {\n *       id: user.id,\n *       email: user.email,\n *       plan: user.subscription.plan\n *     },\n *     'user'  // Custom prefix\n *   )\n *\n *   ctx.setAttributes(userAttrs)\n *   // Results in:\n *   // {\n *   //   'user.id': 'user-123',\n *   //   'user.email': 'user@example.com',\n *   //   'user.plan': 'enterprise'\n *   // }\n * })\n * ```\n *\n * @example With complex objects (auto-serialized)\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const analyzeRequest = withTracing({})(ctx => async (req: Request) => {\n *   const metadata = flattenMetadata({\n *     headers: req.headers,  // Object - will be JSON serialized\n *     query: req.query,       // Object - will be JSON serialized\n *     timestamp: new Date()   // Non-string - will be JSON serialized\n *   })\n *\n *   ctx.setAttributes(metadata)\n *   // Results in:\n *   // {\n *   //   'metadata.headers': '{\"accept\":\"application/json\",...}',\n *   //   'metadata.query': '{\"page\":\"1\",\"limit\":\"10\"}',\n *   //   'metadata.timestamp': '\"2024-01-15T12:00:00.000Z\"'\n *   // }\n * })\n * ```\n *\n * @example Error handling\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n *\n * // Objects with circular references are handled gracefully\n * const circular: any = { a: 1 }\n * circular.self = circular\n *\n * const flattened = flattenMetadata({ data: circular })\n * // Results in:\n * // { 'metadata.data': '<serialization-failed>' }\n * ```\n *\n * @public\n */\n/**\n * Resolve a trace URL from a template string and trace ID.\n *\n * Templates use `{traceId}` as placeholder. Falls back to `OTEL_TRACE_URL_TEMPLATE` env var.\n *\n * @example\n * resolveTraceUrl('https://grafana.example.com/explore?traceId={traceId}', 'abc123')\n * // => 'https://grafana.example.com/explore?traceId=abc123'\n */\nexport function resolveTraceUrl(\n  template: string | undefined,\n  traceId: string,\n): string | undefined {\n  const t = template ?? process.env.OTEL_TRACE_URL_TEMPLATE;\n  if (!t) return undefined;\n  return t.replaceAll('{traceId}', traceId);\n}\n\nexport function flattenMetadata(\n  metadata: Record<string, unknown>,\n  prefix = 'metadata',\n): Record<string, string> {\n  const flattened: Record<string, string> = {};\n  const seen = new WeakSet<object>(); // Track visited objects to detect cycles\n\n  function flatten(obj: Record<string, unknown>, currentPrefix: string): void {\n    for (const [key, value] of Object.entries(obj)) {\n      // Skip null/undefined values\n      if (value == null) continue;\n\n      const attributeKey = `${currentPrefix}.${key}`;\n\n      // Handle primitives directly (string, number, boolean)\n      if (typeof value === 'string') {\n        flattened[attributeKey] = value;\n        continue;\n      }\n      if (typeof value === 'number' || typeof value === 'boolean') {\n        flattened[attributeKey] = String(value);\n        continue;\n      }\n\n      // Recursively flatten plain objects (with cycle detection)\n      if (\n        typeof value === 'object' &&\n        value !== null &&\n        value.constructor === Object\n      ) {\n        // Detect circular references\n        if (seen.has(value)) {\n          flattened[attributeKey] = '<circular-reference>';\n          continue;\n        }\n\n        // Mark as visited and recursively flatten\n        seen.add(value);\n        flatten(value as Record<string, unknown>, attributeKey);\n        continue;\n      }\n\n      // Serialize arrays and other non-plain objects to JSON\n      try {\n        flattened[attributeKey] = JSON.stringify(value);\n      } catch {\n        // Handle circular references or non-serializable objects\n        flattened[attributeKey] = '<serialization-failed>';\n      }\n    }\n  }\n\n  flatten(metadata, prefix);\n  return flattened;\n}\n"],"mappings":"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"}

package/dist/tracer-provider.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer-provider.cjs","names":["trace"],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/** A tracer provider that can be force-flushed (SDK providers implement this). */\ninterface ForceFlushable {\n  forceFlush(): Promise<void>;\n}\n\nfunction isForceFlushable(value: unknown): value is ForceFlushable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as ForceFlushable).forceFlush === 'function'\n  );\n}\n\n/**\n * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and\n * flush-on-shutdown actually export pending spans.\n *\n * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`\n * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK\n * handle silently exports nothing. This falls back to the globally registered\n * provider and unwraps the API's `ProxyTracerProvider` to reach the real\n * delegate, which is where `forceFlush` actually lives.\n *\n * @param sdk - Optional NodeSDK handle to try first.\n * @returns Something with `forceFlush()`, or `undefined` if none is registered.\n */\nexport function getForceFlushableProvider(\n  sdk?: unknown,\n): ForceFlushable | undefined {\n  const candidates: unknown[] = [];\n\n  const sdkAny = sdk as { getTracerProvider?: () => unknown } | undefined;\n  if (sdkAny && typeof sdkAny.getTracerProvider === 'function') {\n    candidates.push(sdkAny.getTracerProvider());\n  }\n\n  const globalProvider = trace.getTracerProvider() as unknown;\n  candidates.push(globalProvider);\n  // The API hands back a ProxyTracerProvider; the real provider (with\n  // forceFlush) sits behind getDelegate().\n  const proxy = globalProvider as { getDelegate?: () => unknown };\n  if (proxy && typeof proxy.getDelegate === 'function') {\n    candidates.push(proxy.getDelegate());\n  }\n\n  return candidates.find(isForceFlushable);\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAOA,yBAAM,kBAAkB;AACjC;AAOA,SAAS,iBAAiB,OAAyC;CACjE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAyB,eAAe;AAEpD;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,KAC4B;CAC5B,MAAM,aAAwB,CAAC;CAE/B,MAAM,SAAS;CACf,IAAI,UAAU,OAAO,OAAO,sBAAsB,YAChD,WAAW,KAAK,OAAO,kBAAkB,CAAC;CAG5C,MAAM,iBAAiBA,yBAAM,kBAAkB;CAC/C,WAAW,KAAK,cAAc;CAG9B,MAAM,QAAQ;CACd,IAAI,SAAS,OAAO,MAAM,gBAAgB,YACxC,WAAW,KAAK,MAAM,YAAY,CAAC;CAGrC,OAAO,WAAW,KAAK,gBAAgB;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}

package/dist/tracer-provider.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer-provider.d.cts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqLgB,yBACd,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCI,4BAA4B;;UASlC;EACR,cAAc;;;;;;;;;;;;;;;iBAwBA,0BACd,gBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDa,iBAAiB,eAAkB,gDAAgB"}

package/dist/tracer-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer-provider.d.ts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqLgB,yBACd,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCI,4BAA4B;;UASlC;EACR,cAAc;;;;;;;;;;;;;;;iBAwBA,0BACd,gBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDa,iBAAiB,eAAkB,gDAAgB"}

package/dist/tracer-provider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer-provider.js","names":[],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/** A tracer provider that can be force-flushed (SDK providers implement this). */\ninterface ForceFlushable {\n  forceFlush(): Promise<void>;\n}\n\nfunction isForceFlushable(value: unknown): value is ForceFlushable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as ForceFlushable).forceFlush === 'function'\n  );\n}\n\n/**\n * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and\n * flush-on-shutdown actually export pending spans.\n *\n * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`\n * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK\n * handle silently exports nothing. This falls back to the globally registered\n * provider and unwraps the API's `ProxyTracerProvider` to reach the real\n * delegate, which is where `forceFlush` actually lives.\n *\n * @param sdk - Optional NodeSDK handle to try first.\n * @returns Something with `forceFlush()`, or `undefined` if none is registered.\n */\nexport function getForceFlushableProvider(\n  sdk?: unknown,\n): ForceFlushable | undefined {\n  const candidates: unknown[] = [];\n\n  const sdkAny = sdk as { getTracerProvider?: () => unknown } | undefined;\n  if (sdkAny && typeof sdkAny.getTracerProvider === 'function') {\n    candidates.push(sdkAny.getTracerProvider());\n  }\n\n  const globalProvider = trace.getTracerProvider() as unknown;\n  candidates.push(globalProvider);\n  // The API hands back a ProxyTracerProvider; the real provider (with\n  // forceFlush) sits behind getDelegate().\n  const proxy = globalProvider as { getDelegate?: () => unknown };\n  if (proxy && typeof proxy.getDelegate === 'function') {\n    candidates.push(proxy.getDelegate());\n  }\n\n  return candidates.find(isForceFlushable);\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAO,MAAM,kBAAkB;AACjC;AAOA,SAAS,iBAAiB,OAAyC;CACjE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAyB,eAAe;AAEpD;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,KAC4B;CAC5B,MAAM,aAAwB,CAAC;CAE/B,MAAM,SAAS;CACf,IAAI,UAAU,OAAO,OAAO,sBAAsB,YAChD,WAAW,KAAK,OAAO,kBAAkB,CAAC;CAG5C,MAAM,iBAAiB,MAAM,kBAAkB;CAC/C,WAAW,KAAK,cAAc;CAG9B,MAAM,QAAQ;CACd,IAAI,SAAS,OAAO,MAAM,gBAAgB,YACxC,WAAW,KAAK,MAAM,YAAY,CAAC;CAGrC,OAAO,WAAW,KAAK,gBAAgB;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}

package/dist/validate.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.cjs","names":["createCounter","VALIDATION_METRICS","trace","VALIDATION_ATTR","createStructuredError","hashJson"],"sources":["../src/validate.ts"],"sourcesContent":["/**\n * Validation telemetry — connect runtime input validation (Zod or any\n * `safeParse` schema) to your traces and metrics at the boundaries where bad\n * data actually enters: HTTP bodies, events, messages.\n *\n * Today a `safeParse` failure either throws (no span, no metric, no alert) or\n * is silently swallowed in a handler. `defineValidator` makes the mismatch\n * **observable** — a `validation.*` span attribute set and a counter\n * incremented — with a per-validator `observe` vs `reject` mode:\n *\n * - `reject` (default): record telemetry, then throw a structured 400-shaped\n *   error so the boundary can fail cleanly.\n * - `observe`: record telemetry, return the raw input so the handler continues\n *   — useful for measuring real-world drift before you enforce it.\n *\n * **Not a security feature by default.** A malformed body is usually a bug or\n * version skew, not an attack. Validation telemetry is first-class on its own\n * metric; escalation to the security path is a deliberate opt-in via\n * {@link onValidationMismatch} (e.g. wired by `autotel-audit`), never automatic.\n *\n * **PII-safe by construction.** Only field *paths*, issue *codes*, and the\n * declared *type* are ever recorded — never the offending value, and never a\n * validator's error `message` (which routinely embeds the received value).\n */\n\nimport { trace } from '@opentelemetry/api';\nimport { createCounter } from './metric-helpers';\nimport {\n  createStructuredError,\n  type StructuredError,\n} from './structured-error';\nimport { hashJson } from './stable-hash';\nimport type { SchemaLike } from './define-event';\nimport {\n  VALIDATION_ATTR,\n  VALIDATION_ISSUE_CAP,\n  VALIDATION_METRICS,\n} from './validation-attributes';\n\nexport type { SchemaLike } from './define-event';\n\nexport type ValidationMode = 'observe' | 'reject';\nexport type ValidationSeverity = 'info' | 'warning' | 'error';\n\n/** A single failing field, stripped of any payload values. */\nexport interface ValidationIssue {\n  /** Dotted field path, e.g. `items.0.price`. Never a value. */\n  path: string;\n  /** Issue code (e.g. Zod's `invalid_type`, `too_small`). Never a value. */\n  code: string;\n  /** Declared type/constraint summary, e.g. `string`. Never a received value. */\n  expected?: string;\n}\n\n/** Everything the recorder needs — already PII-stripped by the caller. */\nexport interface ValidationMismatch {\n  /** Contract id, e.g. `POST /orders` or `order.placed`. */\n  name: string;\n  boundary: string;\n  mode: ValidationMode;\n  issues: ValidationIssue[];\n  hash?: string;\n  severity?: ValidationSeverity;\n}\n\nlet mismatchCounter: ReturnType<typeof createCounter> | undefined;\nfunction counter(): ReturnType<typeof createCounter> {\n  if (!mismatchCounter) {\n    mismatchCounter = createCounter(VALIDATION_METRICS.mismatches, {\n      description: 'Input payloads that did not match their declared shape',\n    });\n  }\n  return mismatchCounter;\n}\n\ntype MismatchListener = (mismatch: ValidationMismatch) => void;\nconst listeners = new Set<MismatchListener>();\n\n/**\n * Register an explicit handler called on every recorded mismatch — the opt-in\n * seam for escalating to security events, a webhook, or a custom sink. There is\n * no automatic, package-presence-driven escalation: nothing fires here unless\n * you (or a package you wire up) register a handler.\n *\n * Multiple subscribers coexist: a package (e.g. `autotel-audit` bridging to\n * security events) and your own app code (a webhook, a logger) can both\n * register and all fire. Returns an unsubscribe fn that removes only this\n * handler; registering the same function twice is a no-op (Set semantics).\n */\nexport function onValidationMismatch(handler: MismatchListener): () => void {\n  listeners.add(handler);\n  return () => {\n    listeners.delete(handler);\n  };\n}\n\nconst truncate = (values: string[]): string =>\n  values.slice(0, VALIDATION_ISSUE_CAP).join(',');\n\n/**\n * Record a validation mismatch as telemetry: `validation.*` attributes on the\n * active span (if any) and an increment on `autotel.validation.mismatches`.\n * Fail-open — never throws, so instrumentation can't break the boundary.\n */\nexport function recordValidationMismatch(mismatch: ValidationMismatch): void {\n  try {\n    const paths = mismatch.issues.map((i) => i.path).filter(Boolean);\n    const codes = [...new Set(mismatch.issues.map((i) => i.code))];\n\n    const span = trace.getActiveSpan();\n    if (span) {\n      span.setAttributes({\n        [VALIDATION_ATTR.name]: mismatch.name,\n        [VALIDATION_ATTR.boundary]: mismatch.boundary,\n        [VALIDATION_ATTR.mode]: mismatch.mode,\n        [VALIDATION_ATTR.issueCount]: mismatch.issues.length,\n        [VALIDATION_ATTR.issuePaths]: truncate(paths),\n        [VALIDATION_ATTR.issueCodes]: truncate(codes),\n        ...(mismatch.hash ? { [VALIDATION_ATTR.hash]: mismatch.hash } : {}),\n        ...(mismatch.severity\n          ? { [VALIDATION_ATTR.severity]: mismatch.severity }\n          : {}),\n      });\n    }\n\n    try {\n      counter().add(1, {\n        boundary: mismatch.boundary,\n        validation: mismatch.name,\n        mode: mismatch.mode,\n      });\n    } catch {\n      // meter not initialised yet — skip the count, keep the span attrs\n    }\n\n    // Dispatch to every subscriber with per-listener fault isolation: one\n    // throwing subscriber must not starve its peers or break the boundary.\n    // Set iteration tolerates concurrent (un)subscription safely.\n    for (const listener of listeners) {\n      try {\n        listener(mismatch);\n      } catch {\n        // a misbehaving subscriber must not break the boundary or its peers\n      }\n    }\n  } catch {\n    // fail-open: telemetry must never break the validated boundary\n  }\n}\n\n/**\n * Normalise an arbitrary validation error into PII-safe issues. Reads only\n * `path`, `code`, and (when it is a declared type name) `expected` — and never\n * `message`, `received`, or any value-bearing field. Understands the Zod shape\n * (`error.issues`) and a generic `error.errors` fallback; returns `[]` for\n * anything unrecognised.\n */\nexport function formatValidationIssues(error: unknown): ValidationIssue[] {\n  const raw = extractRawIssues(error);\n  return raw.map((issue) => toSafeIssue(issue));\n}\n\nfunction extractRawIssues(error: unknown): Array<Record<string, unknown>> {\n  if (error && typeof error === 'object') {\n    const candidate =\n      (error as { issues?: unknown }).issues ??\n      (error as { errors?: unknown }).errors;\n    if (Array.isArray(candidate)) {\n      return candidate.filter(\n        (i): i is Record<string, unknown> =>\n          i !== null && typeof i === 'object',\n      );\n    }\n  }\n  return [];\n}\n\nfunction toSafeIssue(issue: Record<string, unknown>): ValidationIssue {\n  const rawPath = issue.path;\n  const path = Array.isArray(rawPath)\n    ? rawPath.map(String).join('.')\n    : typeof rawPath === 'string'\n      ? rawPath\n      : '';\n  const code = typeof issue.code === 'string' ? issue.code : 'invalid';\n  // `expected` is a declared type name in Zod (e.g. 'string'); safe. We never\n  // read `received`/`message`/`value`, which can carry the offending payload.\n  const expected =\n    typeof issue.expected === 'string' ? issue.expected : undefined;\n  return expected ? { path, code, expected } : { path, code };\n}\n\nexport interface DefineValidatorOptions<S> {\n  /** Where validation runs. Defaults to `input`. */\n  boundary?: string;\n  /** `reject` (default): record then throw. `observe`: record then continue. */\n  onMismatch?: ValidationMode;\n  /** Project the schema to JSON Schema for a stable `validation.hash`. */\n  toJsonSchema?: (schema: S) => unknown;\n  severity?: ValidationSeverity;\n  /** Build the error thrown in `reject` mode (defaults to a 400 structured error). */\n  onReject?: (issues: ValidationIssue[], name: string) => Error;\n}\n\nexport type ValidatorResult<T> =\n  { success: true; data: T } | { success: false; issues: ValidationIssue[] };\n\nexport interface Validator<T> {\n  readonly name: string;\n  readonly mode: ValidationMode;\n  /** Validate and record on failure; never throws. */\n  safeParse(input: unknown): ValidatorResult<T>;\n  /**\n   * Validate, record on failure, then apply the mode: `reject` throws,\n   * `observe` returns the raw input so the handler can continue.\n   */\n  parse(input: unknown): T;\n}\n\nfunction defaultRejectError(\n  issues: ValidationIssue[],\n  name: string,\n): StructuredError {\n  return createStructuredError({\n    name: 'ValidationError',\n    status: 400,\n    code: 'validation_failed',\n    message: `Input for \"${name}\" did not match its declared shape.`,\n    why: `${issues.length} field(s) failed validation: ${issues\n      .map((i) => i.path || '(root)')\n      .slice(0, VALIDATION_ISSUE_CAP)\n      .join(', ')}.`,\n    fix: 'Send a payload that matches the schema, or switch this validator to observe mode while you investigate.',\n    // PII-safe: paths + codes only, no received values.\n    details: { validation: name, issues },\n  });\n}\n\n/**\n * Declare an expected input shape once and get a validator that records every\n * mismatch as telemetry.\n *\n * @example\n * ```ts\n * import { z } from 'zod';\n * import { defineValidator } from 'autotel/validate';\n *\n * const OrderBody = defineValidator('POST /orders', z.object({\n *   items: z.array(z.object({ sku: z.string(), qty: z.number().int() })),\n * }), { boundary: 'http', toJsonSchema: (s) => z.toJSONSchema(s) });\n *\n * // reject mode (default): records + throws a 400-shaped structured error\n * const order = OrderBody.parse(req.body);\n *\n * // observe mode: records, returns the result, never throws\n * const result = OrderBody.safeParse(req.body);\n * if (!result.success) metrics.onDrift(result.issues);\n * ```\n */\nexport function defineValidator<T, S extends SchemaLike<T>>(\n  name: string,\n  schema: S,\n  options: DefineValidatorOptions<S> = {},\n): Validator<T> {\n  const mode = options.onMismatch ?? 'reject';\n  const boundary = options.boundary ?? 'input';\n  const hash = options.toJsonSchema\n    ? hashJson(options.toJsonSchema(schema))\n    : undefined;\n\n  const record = (issues: ValidationIssue[]): void => {\n    recordValidationMismatch({\n      name,\n      boundary,\n      mode,\n      issues,\n      hash,\n      severity: options.severity,\n    });\n  };\n\n  return {\n    name,\n    mode,\n    safeParse(input: unknown): ValidatorResult<T> {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return { success: true, data: parsed.data };\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      return { success: false, issues };\n    },\n    parse(input: unknown): T {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return parsed.data;\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      if (mode === 'reject') {\n        throw (\n          options.onReject?.(issues, name) ?? defaultRejectError(issues, name)\n        );\n      }\n      // observe: continue with the raw input (documented type caveat)\n      return input as T;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/validate.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.cts","names":[],"sources":["../src/validate.ts"],"mappings":";;KAyCY;KACA;;UAGK;;EAEf;;EAEA;;EAEA;;;UAIe;;EAEf;EACA;EACA,MAAM;EACN,QAAQ;EACR;EACA,WAAW;;KAaR,oBAAoB,UAAU;;;;;;;;;;;;iBAcnB,qBAAqB,SAAS;;;;;;iBAe9B,yBAAyB,UAAU;;;;;;;;iBAqDnC,uBAAuB,iBAAiB;UAmCvC,uBAAuB;;EAEtC;;EAEA,aAAa;;EAEb,gBAAgB,QAAQ;EACxB,WAAW;;EAEX,YAAY,QAAQ,mBAAmB,iBAAiB;;KAG9C,gBAAgB;EACxB;EAAe,MAAM;;EAAQ;EAAgB,QAAQ;;UAExC,UAAU;WAChB;WACA,MAAM;;EAEf,UAAU,iBAAiB,gBAAgB;;;;;EAK3C,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2CT,gBAAgB,GAAG,UAAU,WAAW,IACtD,cACA,QAAQ,GACR,UAAS,uBAAuB,KAC/B,UAAU"}

package/dist/validate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","names":[],"sources":["../src/validate.ts"],"mappings":";;KAyCY;KACA;;UAGK;;EAEf;;EAEA;;EAEA;;;UAIe;;EAEf;EACA;EACA,MAAM;EACN,QAAQ;EACR;EACA,WAAW;;KAaR,oBAAoB,UAAU;;;;;;;;;;;;iBAcnB,qBAAqB,SAAS;;;;;;iBAe9B,yBAAyB,UAAU;;;;;;;;iBAqDnC,uBAAuB,iBAAiB;UAmCvC,uBAAuB;;EAEtC;;EAEA,aAAa;;EAEb,gBAAgB,QAAQ;EACxB,WAAW;;EAEX,YAAY,QAAQ,mBAAmB,iBAAiB;;KAG9C,gBAAgB;EACxB;EAAe,MAAM;;EAAQ;EAAgB,QAAQ;;UAExC,UAAU;WAChB;WACA,MAAM;;EAEf,UAAU,iBAAiB,gBAAgB;;;;;EAK3C,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2CT,gBAAgB,GAAG,UAAU,WAAW,IACtD,cACA,QAAQ,GACR,UAAS,uBAAuB,KAC/B,UAAU"}

package/dist/validate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.js","names":[],"sources":["../src/validate.ts"],"sourcesContent":["/**\n * Validation telemetry — connect runtime input validation (Zod or any\n * `safeParse` schema) to your traces and metrics at the boundaries where bad\n * data actually enters: HTTP bodies, events, messages.\n *\n * Today a `safeParse` failure either throws (no span, no metric, no alert) or\n * is silently swallowed in a handler. `defineValidator` makes the mismatch\n * **observable** — a `validation.*` span attribute set and a counter\n * incremented — with a per-validator `observe` vs `reject` mode:\n *\n * - `reject` (default): record telemetry, then throw a structured 400-shaped\n *   error so the boundary can fail cleanly.\n * - `observe`: record telemetry, return the raw input so the handler continues\n *   — useful for measuring real-world drift before you enforce it.\n *\n * **Not a security feature by default.** A malformed body is usually a bug or\n * version skew, not an attack. Validation telemetry is first-class on its own\n * metric; escalation to the security path is a deliberate opt-in via\n * {@link onValidationMismatch} (e.g. wired by `autotel-audit`), never automatic.\n *\n * **PII-safe by construction.** Only field *paths*, issue *codes*, and the\n * declared *type* are ever recorded — never the offending value, and never a\n * validator's error `message` (which routinely embeds the received value).\n */\n\nimport { trace } from '@opentelemetry/api';\nimport { createCounter } from './metric-helpers';\nimport {\n  createStructuredError,\n  type StructuredError,\n} from './structured-error';\nimport { hashJson } from './stable-hash';\nimport type { SchemaLike } from './define-event';\nimport {\n  VALIDATION_ATTR,\n  VALIDATION_ISSUE_CAP,\n  VALIDATION_METRICS,\n} from './validation-attributes';\n\nexport type { SchemaLike } from './define-event';\n\nexport type ValidationMode = 'observe' | 'reject';\nexport type ValidationSeverity = 'info' | 'warning' | 'error';\n\n/** A single failing field, stripped of any payload values. */\nexport interface ValidationIssue {\n  /** Dotted field path, e.g. `items.0.price`. Never a value. */\n  path: string;\n  /** Issue code (e.g. Zod's `invalid_type`, `too_small`). Never a value. */\n  code: string;\n  /** Declared type/constraint summary, e.g. `string`. Never a received value. */\n  expected?: string;\n}\n\n/** Everything the recorder needs — already PII-stripped by the caller. */\nexport interface ValidationMismatch {\n  /** Contract id, e.g. `POST /orders` or `order.placed`. */\n  name: string;\n  boundary: string;\n  mode: ValidationMode;\n  issues: ValidationIssue[];\n  hash?: string;\n  severity?: ValidationSeverity;\n}\n\nlet mismatchCounter: ReturnType<typeof createCounter> | undefined;\nfunction counter(): ReturnType<typeof createCounter> {\n  if (!mismatchCounter) {\n    mismatchCounter = createCounter(VALIDATION_METRICS.mismatches, {\n      description: 'Input payloads that did not match their declared shape',\n    });\n  }\n  return mismatchCounter;\n}\n\ntype MismatchListener = (mismatch: ValidationMismatch) => void;\nconst listeners = new Set<MismatchListener>();\n\n/**\n * Register an explicit handler called on every recorded mismatch — the opt-in\n * seam for escalating to security events, a webhook, or a custom sink. There is\n * no automatic, package-presence-driven escalation: nothing fires here unless\n * you (or a package you wire up) register a handler.\n *\n * Multiple subscribers coexist: a package (e.g. `autotel-audit` bridging to\n * security events) and your own app code (a webhook, a logger) can both\n * register and all fire. Returns an unsubscribe fn that removes only this\n * handler; registering the same function twice is a no-op (Set semantics).\n */\nexport function onValidationMismatch(handler: MismatchListener): () => void {\n  listeners.add(handler);\n  return () => {\n    listeners.delete(handler);\n  };\n}\n\nconst truncate = (values: string[]): string =>\n  values.slice(0, VALIDATION_ISSUE_CAP).join(',');\n\n/**\n * Record a validation mismatch as telemetry: `validation.*` attributes on the\n * active span (if any) and an increment on `autotel.validation.mismatches`.\n * Fail-open — never throws, so instrumentation can't break the boundary.\n */\nexport function recordValidationMismatch(mismatch: ValidationMismatch): void {\n  try {\n    const paths = mismatch.issues.map((i) => i.path).filter(Boolean);\n    const codes = [...new Set(mismatch.issues.map((i) => i.code))];\n\n    const span = trace.getActiveSpan();\n    if (span) {\n      span.setAttributes({\n        [VALIDATION_ATTR.name]: mismatch.name,\n        [VALIDATION_ATTR.boundary]: mismatch.boundary,\n        [VALIDATION_ATTR.mode]: mismatch.mode,\n        [VALIDATION_ATTR.issueCount]: mismatch.issues.length,\n        [VALIDATION_ATTR.issuePaths]: truncate(paths),\n        [VALIDATION_ATTR.issueCodes]: truncate(codes),\n        ...(mismatch.hash ? { [VALIDATION_ATTR.hash]: mismatch.hash } : {}),\n        ...(mismatch.severity\n          ? { [VALIDATION_ATTR.severity]: mismatch.severity }\n          : {}),\n      });\n    }\n\n    try {\n      counter().add(1, {\n        boundary: mismatch.boundary,\n        validation: mismatch.name,\n        mode: mismatch.mode,\n      });\n    } catch {\n      // meter not initialised yet — skip the count, keep the span attrs\n    }\n\n    // Dispatch to every subscriber with per-listener fault isolation: one\n    // throwing subscriber must not starve its peers or break the boundary.\n    // Set iteration tolerates concurrent (un)subscription safely.\n    for (const listener of listeners) {\n      try {\n        listener(mismatch);\n      } catch {\n        // a misbehaving subscriber must not break the boundary or its peers\n      }\n    }\n  } catch {\n    // fail-open: telemetry must never break the validated boundary\n  }\n}\n\n/**\n * Normalise an arbitrary validation error into PII-safe issues. Reads only\n * `path`, `code`, and (when it is a declared type name) `expected` — and never\n * `message`, `received`, or any value-bearing field. Understands the Zod shape\n * (`error.issues`) and a generic `error.errors` fallback; returns `[]` for\n * anything unrecognised.\n */\nexport function formatValidationIssues(error: unknown): ValidationIssue[] {\n  const raw = extractRawIssues(error);\n  return raw.map((issue) => toSafeIssue(issue));\n}\n\nfunction extractRawIssues(error: unknown): Array<Record<string, unknown>> {\n  if (error && typeof error === 'object') {\n    const candidate =\n      (error as { issues?: unknown }).issues ??\n      (error as { errors?: unknown }).errors;\n    if (Array.isArray(candidate)) {\n      return candidate.filter(\n        (i): i is Record<string, unknown> =>\n          i !== null && typeof i === 'object',\n      );\n    }\n  }\n  return [];\n}\n\nfunction toSafeIssue(issue: Record<string, unknown>): ValidationIssue {\n  const rawPath = issue.path;\n  const path = Array.isArray(rawPath)\n    ? rawPath.map(String).join('.')\n    : typeof rawPath === 'string'\n      ? rawPath\n      : '';\n  const code = typeof issue.code === 'string' ? issue.code : 'invalid';\n  // `expected` is a declared type name in Zod (e.g. 'string'); safe. We never\n  // read `received`/`message`/`value`, which can carry the offending payload.\n  const expected =\n    typeof issue.expected === 'string' ? issue.expected : undefined;\n  return expected ? { path, code, expected } : { path, code };\n}\n\nexport interface DefineValidatorOptions<S> {\n  /** Where validation runs. Defaults to `input`. */\n  boundary?: string;\n  /** `reject` (default): record then throw. `observe`: record then continue. */\n  onMismatch?: ValidationMode;\n  /** Project the schema to JSON Schema for a stable `validation.hash`. */\n  toJsonSchema?: (schema: S) => unknown;\n  severity?: ValidationSeverity;\n  /** Build the error thrown in `reject` mode (defaults to a 400 structured error). */\n  onReject?: (issues: ValidationIssue[], name: string) => Error;\n}\n\nexport type ValidatorResult<T> =\n  { success: true; data: T } | { success: false; issues: ValidationIssue[] };\n\nexport interface Validator<T> {\n  readonly name: string;\n  readonly mode: ValidationMode;\n  /** Validate and record on failure; never throws. */\n  safeParse(input: unknown): ValidatorResult<T>;\n  /**\n   * Validate, record on failure, then apply the mode: `reject` throws,\n   * `observe` returns the raw input so the handler can continue.\n   */\n  parse(input: unknown): T;\n}\n\nfunction defaultRejectError(\n  issues: ValidationIssue[],\n  name: string,\n): StructuredError {\n  return createStructuredError({\n    name: 'ValidationError',\n    status: 400,\n    code: 'validation_failed',\n    message: `Input for \"${name}\" did not match its declared shape.`,\n    why: `${issues.length} field(s) failed validation: ${issues\n      .map((i) => i.path || '(root)')\n      .slice(0, VALIDATION_ISSUE_CAP)\n      .join(', ')}.`,\n    fix: 'Send a payload that matches the schema, or switch this validator to observe mode while you investigate.',\n    // PII-safe: paths + codes only, no received values.\n    details: { validation: name, issues },\n  });\n}\n\n/**\n * Declare an expected input shape once and get a validator that records every\n * mismatch as telemetry.\n *\n * @example\n * ```ts\n * import { z } from 'zod';\n * import { defineValidator } from 'autotel/validate';\n *\n * const OrderBody = defineValidator('POST /orders', z.object({\n *   items: z.array(z.object({ sku: z.string(), qty: z.number().int() })),\n * }), { boundary: 'http', toJsonSchema: (s) => z.toJSONSchema(s) });\n *\n * // reject mode (default): records + throws a 400-shaped structured error\n * const order = OrderBody.parse(req.body);\n *\n * // observe mode: records, returns the result, never throws\n * const result = OrderBody.safeParse(req.body);\n * if (!result.success) metrics.onDrift(result.issues);\n * ```\n */\nexport function defineValidator<T, S extends SchemaLike<T>>(\n  name: string,\n  schema: S,\n  options: DefineValidatorOptions<S> = {},\n): Validator<T> {\n  const mode = options.onMismatch ?? 'reject';\n  const boundary = options.boundary ?? 'input';\n  const hash = options.toJsonSchema\n    ? hashJson(options.toJsonSchema(schema))\n    : undefined;\n\n  const record = (issues: ValidationIssue[]): void => {\n    recordValidationMismatch({\n      name,\n      boundary,\n      mode,\n      issues,\n      hash,\n      severity: options.severity,\n    });\n  };\n\n  return {\n    name,\n    mode,\n    safeParse(input: unknown): ValidatorResult<T> {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return { success: true, data: parsed.data };\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      return { success: false, issues };\n    },\n    parse(input: unknown): T {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return parsed.data;\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      if (mode === 'reject') {\n        throw (\n          options.onReject?.(issues, name) ?? defaultRejectError(issues, name)\n        );\n      }\n      // observe: continue with the raw input (documented type caveat)\n      return input as T;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/validation-attributes.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-attributes.cjs","names":[],"sources":["../src/validation-attributes.ts"],"sourcesContent":["/**\n * Validation telemetry wire constants — the single source of truth for the\n * `validation.*` span attributes and the `autotel.validation.mismatches` metric\n * emitted when an input payload (HTTP body, event, message) fails to match its\n * declared shape.\n *\n * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):\n * safe to import from anything that only needs the constant strings — a\n * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.\n *\n * These keys are a public API for the agents that query your telemetry. Treat a\n * rename here the way you'd treat a breaking change to any other contract.\n */\n\nexport const VALIDATION_ATTR = {\n  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */\n  name: 'validation.name',\n  /** Where validation ran: `http` | `event` | `message` | a custom label. */\n  boundary: 'validation.boundary',\n  /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */\n  mode: 'validation.mode',\n  /** Stable hash of the declared shape, when a JSON-schema projection is given. */\n  hash: 'validation.hash',\n  /** `info` | `warning` | `error`. */\n  severity: 'validation.severity',\n  /** Number of failing fields. */\n  issueCount: 'validation.issue.count',\n  /** Comma-separated failing field paths (capped). Never contains values. */\n  issuePaths: 'validation.issue.paths',\n  /** Comma-separated distinct issue codes (capped). Never contains values. */\n  issueCodes: 'validation.issue.codes',\n} as const;\n\nexport type ValidationAttributeKey =\n  (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];\n\nexport const VALIDATION_METRICS = {\n  /** Counter, labelled `{ boundary, validation, mode }`. */\n  mismatches: 'autotel.validation.mismatches',\n} as const;\n\n/** Max field paths / codes stamped onto a span, to bound attribute size. */\nexport const VALIDATION_ISSUE_CAP = 20;\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAa,kBAAkB;;CAE7B,MAAM;;CAEN,UAAU;;CAEV,MAAM;;CAEN,MAAM;;CAEN,UAAU;;CAEV,YAAY;;CAEZ,YAAY;;CAEZ,YAAY;AACd;AAKA,MAAa,qBAAqB;;AAEhC,YAAY,gCACd;;AAGA,MAAa,uBAAuB"}

package/dist/validation-attributes.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-attributes.d.cts","names":[],"sources":["../src/validation-attributes.ts"],"mappings":";;;;;;;;;;;;;;cAca;;;;;;;;;;;;;;;;;;KAmBD,iCACF,8BAA8B;cAE3B;;WAAA;;;cAMA"}

package/dist/validation-attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-attributes.d.ts","names":[],"sources":["../src/validation-attributes.ts"],"mappings":";;;;;;;;;;;;;;cAca;;;;;;;;;;;;;;;;;;KAmBD,iCACF,8BAA8B;cAE3B;;WAAA;;;cAMA"}

package/dist/validation-attributes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-attributes.js","names":[],"sources":["../src/validation-attributes.ts"],"sourcesContent":["/**\n * Validation telemetry wire constants — the single source of truth for the\n * `validation.*` span attributes and the `autotel.validation.mismatches` metric\n * emitted when an input payload (HTTP body, event, message) fails to match its\n * declared shape.\n *\n * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):\n * safe to import from anything that only needs the constant strings — a\n * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.\n *\n * These keys are a public API for the agents that query your telemetry. Treat a\n * rename here the way you'd treat a breaking change to any other contract.\n */\n\nexport const VALIDATION_ATTR = {\n  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */\n  name: 'validation.name',\n  /** Where validation ran: `http` | `event` | `message` | a custom label. */\n  boundary: 'validation.boundary',\n  /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */\n  mode: 'validation.mode',\n  /** Stable hash of the declared shape, when a JSON-schema projection is given. */\n  hash: 'validation.hash',\n  /** `info` | `warning` | `error`. */\n  severity: 'validation.severity',\n  /** Number of failing fields. */\n  issueCount: 'validation.issue.count',\n  /** Comma-separated failing field paths (capped). Never contains values. */\n  issuePaths: 'validation.issue.paths',\n  /** Comma-separated distinct issue codes (capped). Never contains values. */\n  issueCodes: 'validation.issue.codes',\n} as const;\n\nexport type ValidationAttributeKey =\n  (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];\n\nexport const VALIDATION_METRICS = {\n  /** Counter, labelled `{ boundary, validation, mode }`. */\n  mismatches: 'autotel.validation.mismatches',\n} as const;\n\n/** Max field paths / codes stamped onto a span, to bound attribute size. */\nexport const VALIDATION_ISSUE_CAP = 20;\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAa,kBAAkB;;CAE7B,MAAM;;CAEN,UAAU;;CAEV,MAAM;;CAEN,MAAM;;CAEN,UAAU;;CAEV,YAAY;;CAEZ,YAAY;;CAEZ,YAAY;AACd;AAKA,MAAa,qBAAqB;;AAEhC,YAAY,gCACd;;AAGA,MAAa,uBAAuB"}

package/dist/webhook.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"webhook.cjs","names":["otelTrace","withTracing","SpanKind"],"sources":["../src/webhook.ts"],"sourcesContent":["/**\n * Webhook and callback tracing with the \"Parking Lot\" pattern\n *\n * When initiating async operations that return hours/days later (webhooks,\n * payment callbacks, human approvals), you can't keep a span open. This module\n * provides utilities to \"park\" trace context and retrieve it when callbacks arrive.\n *\n * @example Stripe payment webhook\n * ```typescript\n * import { createParkingLot, InMemoryTraceContextStore } from 'autotel/webhook';\n * import { withTracing } from 'autotel';\n *\n * const parkingLot = createParkingLot({\n *   store: new InMemoryTraceContextStore(),\n *   defaultTTLMs: 24 * 60 * 60 * 1000, // 24 hours\n * });\n *\n * // When initiating payment\n * export const initiatePayment = withTracing({})(ctx => async (orderId: string) => {\n *   await parkingLot.park(`payment:${orderId}`, { orderId });\n *   await stripeClient.createPaymentIntent({ metadata: { orderId } });\n * });\n *\n * // When Stripe webhook arrives (hours later)\n * export const handleStripeWebhook = parkingLot.traceCallback({\n *   name: 'stripe.webhook.payment_intent.succeeded',\n *   correlationKeyFrom: (event) => `payment:${event.data.object.metadata.orderId}`,\n * })(ctx => async (event: Stripe.Event) => {\n *   // ctx.parkedContext contains the original trace context\n *   // ctx.elapsedMs shows time since payment was initiated\n *   await fulfillOrder(event.data.object);\n * });\n * ```\n *\n * @module\n */\n\nimport { SpanKind, trace as otelTrace } from '@opentelemetry/api';\nimport type { SpanContext, Link } from '@opentelemetry/api';\nimport { emitCorrelatedEvent } from './correlated-events';\nimport { withTracing } from './functional';\nimport type { AttributeValue, TraceContext } from './trace-context';\nimport { recordStructuredError } from './structured-error';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Stored trace context for parking lot pattern\n */\nexport interface StoredTraceContext {\n  /** Trace ID from the original span */\n  traceId: string;\n\n  /** Span ID from the original span */\n  spanId: string;\n\n  /** Trace flags (sampling decision) */\n  traceFlags: number;\n\n  /** When the context was parked */\n  parkedAt: number;\n\n  /** Optional TTL in milliseconds */\n  ttlMs?: number;\n\n  /** User-provided metadata */\n  metadata?: Record<string, string>;\n}\n\n/**\n * Interface for trace context storage backends\n *\n * Implement this interface to use different storage backends (Redis, DynamoDB, etc.)\n */\nexport interface TraceContextStore {\n  /**\n   * Save trace context with a correlation key\n   *\n   * @param key - Unique correlation key (e.g., \"payment:order-123\")\n   * @param context - The trace context to store\n   */\n  save(key: string, context: StoredTraceContext): Promise<void>;\n\n  /**\n   * Load trace context by correlation key\n   *\n   * @param key - The correlation key used when parking\n   * @returns The stored context, or null if not found/expired\n   */\n  load(key: string): Promise<StoredTraceContext | null>;\n\n  /**\n   * Delete trace context by correlation key\n   *\n   * @param key - The correlation key to delete\n   */\n  delete(key: string): Promise<void>;\n}\n\n/**\n * Configuration for creating a parking lot\n */\nexport interface ParkingLotConfig {\n  /** Storage backend for parked contexts */\n  store: TraceContextStore;\n\n  /** Default TTL in milliseconds (default: 24 hours) */\n  defaultTTLMs?: number;\n\n  /** Prefix for all correlation keys (default: \"parkingLot:\") */\n  keyPrefix?: string;\n\n  /** Whether to auto-delete after retrieval (default: true) */\n  autoDeleteOnRetrieve?: boolean;\n\n  /** Callback when context expires or is not found */\n  onMiss?: (correlationKey: string) => void;\n}\n\n/**\n * Configuration for traceCallback wrapper\n */\nexport interface CallbackConfig {\n  /** Span name for the callback handler */\n  name: string;\n\n  /**\n   * Extract correlation key from callback arguments\n   *\n   * @example\n   * ```typescript\n   * correlationKeyFrom: (event) => `payment:${event.data.orderId}`\n   * ```\n   */\n  correlationKeyFrom: (args: unknown[]) => string;\n\n  /** Additional span attributes */\n  attributes?: Record<string, string | number | boolean>;\n\n  /** Whether to fail if parked context is not found (default: false) */\n  requireParkedContext?: boolean;\n}\n\n/**\n * Extended context for callback handlers\n */\nexport interface CallbackContext extends TraceContext {\n  /** The retrieved parked context, if found */\n  parkedContext: StoredTraceContext | null;\n\n  /** Time elapsed since context was parked (ms), or null if not found */\n  elapsedMs: number | null;\n\n  /** The correlation key used for retrieval */\n  correlationKey: string;\n}\n\n/**\n * The parking lot instance\n */\nexport interface ParkingLot {\n  /**\n   * Park current trace context before initiating async operation\n   *\n   * Call this before sending a webhook, initiating a payment, or starting\n   * any operation that will complete via callback.\n   *\n   * @param correlationKey - Unique key to retrieve context later (e.g., \"payment:order-123\")\n   * @param metadata - Optional metadata to store with the context\n   * @returns The correlation key (with prefix applied)\n   *\n   * @example\n   * ```typescript\n   * await parkingLot.park(`payment:${orderId}`, {\n   *   customerId: customer.id,\n   *   amount: payment.amount.toString(),\n   * });\n   * ```\n   */\n  park(\n    correlationKey: string,\n    metadata?: Record<string, string>,\n  ): Promise<string>;\n\n  /**\n   * Retrieve parked context when callback arrives\n   *\n   * @param correlationKey - The key used when parking\n   * @returns The stored context, or null if not found/expired\n   */\n  retrieve(correlationKey: string): Promise<StoredTraceContext | null>;\n\n  /**\n   * Wrap a callback handler with automatic context retrieval and linking\n   *\n   * Creates a traced function that:\n   * 1. Extracts correlation key from arguments\n   * 2. Retrieves parked context from storage\n   * 3. Creates a span link to the original trace\n   * 4. Provides elapsed time since parking\n   *\n   * @param config - Callback configuration\n   * @returns Factory function for the callback handler\n   *\n   * @example\n   * ```typescript\n   * export const handleWebhook = parkingLot.traceCallback({\n   *   name: 'webhook.payment.completed',\n   *   correlationKeyFrom: (args) => `payment:${args[0].orderId}`,\n   * })(ctx => async (event) => {\n   *   console.log(`Payment completed after ${ctx.elapsedMs}ms`);\n   *   await processPayment(event);\n   * });\n   * ```\n   */\n  traceCallback(\n    config: CallbackConfig,\n  ): <TArgs extends unknown[], TReturn>(\n    fnFactory: (ctx: CallbackContext) => (...args: TArgs) => Promise<TReturn>,\n  ) => (...args: TArgs) => Promise<TReturn>;\n\n  /**\n   * Manually create a span link from stored context\n   *\n   * Useful when you need more control over span creation.\n   *\n   * @param storedContext - The stored trace context\n   * @returns A span link that can be added to a span\n   */\n  createLink(storedContext: StoredTraceContext): Link;\n\n  /**\n   * Check if a parked context exists (without retrieving/deleting it)\n   *\n   * @param correlationKey - The key to check\n   * @returns True if context exists and hasn't expired\n   */\n  exists(correlationKey: string): Promise<boolean>;\n}\n\n// ============================================================================\n// In-Memory Store (for testing and development)\n// ============================================================================\n\n/**\n * In-memory trace context store\n *\n * Useful for testing and development. For production, use a persistent\n * store like Redis or DynamoDB.\n *\n * @example\n * ```typescript\n * const store = new InMemoryTraceContextStore();\n * const parkingLot = createParkingLot({ store });\n * ```\n */\nexport class InMemoryTraceContextStore implements TraceContextStore {\n  private store = new Map<string, StoredTraceContext>();\n  private cleanupInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    private options: {\n      /** Cleanup interval in ms (default: 60000) */\n      cleanupIntervalMs?: number;\n    } = {},\n  ) {\n    // Start periodic cleanup of expired entries\n    const cleanupMs = options.cleanupIntervalMs ?? 60_000;\n    if (cleanupMs > 0) {\n      this.cleanupInterval = setInterval(() => this.cleanup(), cleanupMs);\n      // Don't prevent process exit\n      if (this.cleanupInterval.unref) {\n        this.cleanupInterval.unref();\n      }\n    }\n  }\n\n  async save(key: string, context: StoredTraceContext): Promise<void> {\n    this.store.set(key, context);\n  }\n\n  async load(key: string): Promise<StoredTraceContext | null> {\n    const context = this.store.get(key);\n    if (!context) {\n      return null;\n    }\n\n    // Check TTL expiration\n    if (context.ttlMs) {\n      const age = Date.now() - context.parkedAt;\n      if (age > context.ttlMs) {\n        this.store.delete(key);\n        return null;\n      }\n    }\n\n    return context;\n  }\n\n  async delete(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n\n  /**\n   * Get number of stored contexts (for testing)\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Clear all stored contexts (for testing)\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Stop the cleanup interval\n   */\n  destroy(): void {\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = null;\n    }\n  }\n\n  private cleanup(): void {\n    const now = Date.now();\n    for (const [key, context] of this.store.entries()) {\n      if (context.ttlMs) {\n        const age = now - context.parkedAt;\n        if (age > context.ttlMs) {\n          this.store.delete(key);\n        }\n      }\n    }\n  }\n}\n\n// ============================================================================\n// Parking Lot Factory\n// ============================================================================\n\n/**\n * Create a parking lot for trace context storage and retrieval\n *\n * @param config - Parking lot configuration\n * @returns A parking lot instance\n *\n * @example Basic usage\n * ```typescript\n * const parkingLot = createParkingLot({\n *   store: new InMemoryTraceContextStore(),\n *   defaultTTLMs: 24 * 60 * 60 * 1000, // 24 hours\n * });\n * ```\n *\n * @example With Redis store\n * ```typescript\n * class RedisTraceContextStore implements TraceContextStore {\n *   constructor(private redis: Redis) {}\n *\n *   async save(key: string, context: StoredTraceContext) {\n *     const ttlSeconds = context.ttlMs ? Math.ceil(context.ttlMs / 1000) : 86400;\n *     await this.redis.setex(key, ttlSeconds, JSON.stringify(context));\n *   }\n *\n *   async load(key: string) {\n *     const data = await this.redis.get(key);\n *     return data ? JSON.parse(data) : null;\n *   }\n *\n *   async delete(key: string) {\n *     await this.redis.del(key);\n *   }\n * }\n *\n * const parkingLot = createParkingLot({\n *   store: new RedisTraceContextStore(redis),\n * });\n * ```\n */\nexport function createParkingLot(config: ParkingLotConfig): ParkingLot {\n  const {\n    store,\n    defaultTTLMs = 24 * 60 * 60 * 1000, // 24 hours\n    keyPrefix = 'parkingLot:',\n    autoDeleteOnRetrieve = true,\n    onMiss,\n  } = config;\n\n  /**\n   * Get current span context from active context\n   */\n  function getCurrentSpanContext(): SpanContext | null {\n    const activeSpan = otelTrace.getActiveSpan();\n    if (!activeSpan) {\n      return null;\n    }\n    return activeSpan.spanContext();\n  }\n\n  /**\n   * Apply key prefix\n   */\n  function prefixKey(key: string): string {\n    return `${keyPrefix}${key}`;\n  }\n\n  const parkingLot: ParkingLot = {\n    async park(\n      correlationKey: string,\n      metadata?: Record<string, string>,\n    ): Promise<string> {\n      const spanContext = getCurrentSpanContext();\n      const fullKey = prefixKey(correlationKey);\n\n      const storedContext: StoredTraceContext = {\n        traceId: spanContext?.traceId ?? '',\n        spanId: spanContext?.spanId ?? '',\n        traceFlags: spanContext?.traceFlags ?? 0,\n        parkedAt: Date.now(),\n        ttlMs: defaultTTLMs,\n        metadata,\n      };\n\n      await store.save(fullKey, storedContext);\n\n      const activeSpan = otelTrace.getActiveSpan();\n      if (activeSpan) {\n        const parkAttrs: Record<string, AttributeValue> = {\n          'parking_lot.correlation_key': correlationKey,\n          'parking_lot.ttl_ms': defaultTTLMs,\n          ...(metadata &&\n            Object.fromEntries(\n              Object.entries(metadata).map(([k, v]) => [\n                `parking_lot.metadata.${k}`,\n                v,\n              ]),\n            )),\n        };\n        emitCorrelatedEvent(\n          {\n            setAttribute: (k, v) => activeSpan.setAttribute(k, v),\n            setAttributes: (a) => activeSpan.setAttributes(a),\n            addEvent: (n, a) => activeSpan.addEvent(n, a),\n          },\n          'trace_context_parked',\n          parkAttrs,\n        );\n      }\n\n      // Return the unprefixed key so callers can use the same key for retrieve()\n      return correlationKey;\n    },\n\n    async retrieve(correlationKey: string): Promise<StoredTraceContext | null> {\n      const fullKey = prefixKey(correlationKey);\n      const storedContext = await store.load(fullKey);\n\n      if (!storedContext) {\n        onMiss?.(correlationKey);\n        return null;\n      }\n\n      if (autoDeleteOnRetrieve) {\n        await store.delete(fullKey);\n      }\n\n      return storedContext;\n    },\n\n    traceCallback(\n      callbackConfig: CallbackConfig,\n    ): <TArgs extends unknown[], TReturn>(\n      fnFactory: (ctx: CallbackContext) => (...args: TArgs) => Promise<TReturn>,\n    ) => (...args: TArgs) => Promise<TReturn> {\n      return <TArgs extends unknown[], TReturn>(\n        fnFactory: (\n          ctx: CallbackContext,\n        ) => (...args: TArgs) => Promise<TReturn>,\n      ): ((...args: TArgs) => Promise<TReturn>) => {\n        return withTracing<TArgs, TReturn>({\n          name: callbackConfig.name,\n          spanKind: SpanKind.SERVER,\n        })((baseCtx) => {\n          return async (...args: TArgs) => {\n            // Extract correlation key from arguments\n            const correlationKey = callbackConfig.correlationKeyFrom(args);\n\n            // Retrieve parked context\n            const parkedContext = await parkingLot.retrieve(correlationKey);\n\n            // Calculate elapsed time\n            const elapsedMs = parkedContext\n              ? Date.now() - parkedContext.parkedAt\n              : null;\n\n            // Set span attributes\n            baseCtx.setAttribute('parking_lot.correlation_key', correlationKey);\n\n            if (parkedContext) {\n              baseCtx.setAttribute('parking_lot.elapsed_ms', elapsedMs!);\n              baseCtx.setAttribute(\n                'parking_lot.original_trace_id',\n                parkedContext.traceId,\n              );\n              baseCtx.setAttribute(\n                'parking_lot.original_span_id',\n                parkedContext.spanId,\n              );\n\n              // Add metadata as attributes\n              if (parkedContext.metadata) {\n                for (const [key, value] of Object.entries(\n                  parkedContext.metadata,\n                )) {\n                  baseCtx.setAttribute(`parking_lot.metadata.${key}`, value);\n                }\n              }\n\n              // Create span link to original trace\n              const link = parkingLot.createLink(parkedContext);\n              baseCtx.addLinks([link]);\n\n              emitCorrelatedEvent(baseCtx, 'parked_context_retrieved', {\n                'parking_lot.correlation_key': correlationKey,\n                'parking_lot.elapsed_ms': elapsedMs!,\n                'parking_lot.original_trace_id': parkedContext.traceId,\n              });\n            } else {\n              baseCtx.setAttribute('parking_lot.context_found', false);\n\n              if (callbackConfig.requireParkedContext) {\n                const error = new Error(\n                  `Required parked context not found for key: ${correlationKey}`,\n                );\n                recordStructuredError(baseCtx, error);\n                throw error;\n              }\n            }\n\n            // Apply custom attributes\n            if (callbackConfig.attributes) {\n              for (const [key, value] of Object.entries(\n                callbackConfig.attributes,\n              )) {\n                baseCtx.setAttribute(key, value);\n              }\n            }\n\n            // Create extended context\n            const callbackCtx: CallbackContext = {\n              ...baseCtx,\n              parkedContext,\n              elapsedMs,\n              correlationKey,\n            };\n\n            // Execute user's function\n            const userFn = fnFactory(callbackCtx);\n            return userFn(...args);\n          };\n        }) as (...args: TArgs) => Promise<TReturn>; // async factory always returns a Promise\n      };\n    },\n\n    createLink(storedContext: StoredTraceContext): Link {\n      return {\n        context: {\n          traceId: storedContext.traceId,\n          spanId: storedContext.spanId,\n          traceFlags: storedContext.traceFlags,\n          isRemote: true,\n        },\n        attributes: {\n          'link.type': 'parking_lot',\n          'parking_lot.parked_at': storedContext.parkedAt,\n          ...(storedContext.metadata && {\n            'parking_lot.has_metadata': true,\n          }),\n        },\n      };\n    },\n\n    async exists(correlationKey: string): Promise<boolean> {\n      const fullKey = prefixKey(correlationKey);\n      const context = await store.load(fullKey);\n      return context !== null;\n    },\n  };\n\n  return parkingLot;\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Create a correlation key from multiple parts\n *\n * @param parts - Key parts to join\n * @returns A correlation key string\n *\n * @example\n * ```typescript\n * const key = createCorrelationKey('payment', orderId, 'stripe');\n * // Returns: \"payment:order-123:stripe\"\n * ```\n */\nexport function createCorrelationKey(...parts: (string | number)[]): string {\n  return parts.map(String).join(':');\n}\n\n/**\n * Extract span context from stored context for manual linking\n *\n * @param storedContext - The stored trace context\n * @returns SpanContext compatible object\n */\nexport function toSpanContext(storedContext: StoredTraceContext): SpanContext {\n  return {\n    traceId: storedContext.traceId,\n    spanId: storedContext.spanId,\n    traceFlags: storedContext.traceFlags,\n    isRemote: true,\n  };\n}\n"],"mappings":"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"}

package/dist/webhook.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webhook.d.cts","names":[],"sources":["../src/webhook.ts"],"mappings":";;;;;;UAmDiB;;EAEf;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,WAAW;;;;;;;UAQI;;;;;;;EAOf,KAAK,aAAa,SAAS,qBAAqB;;;;;;;EAQhD,KAAK,cAAc,QAAQ;;;;;;EAO3B,OAAO,cAAc;;;;;UAMN;;EAEf,OAAO;;EAGP;;EAGA;;EAGA;;EAGA,UAAU;;;;;UAMK;;EAEf;;;;;;;;;EAUA,qBAAqB;;EAGrB,aAAa;;EAGb;;;;;UAMe,wBAAwB;;EAEvC,eAAe;;EAGf;;EAGA;;;;;UAMe;;;;;;;;;;;;;;;;;;;EAmBf,KACE,wBACA,WAAW,yBACV;;;;;;;EAQH,SAAS,yBAAyB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,cACE,QAAQ,kBACN,yBAAyB,SAC3B,YAAY,KAAK,wBAAwB,MAAM,UAAU,QAAQ,iBAC1D,MAAM,UAAU,QAAQ;;;;;;;;;EAUjC,WAAW,eAAe,qBAAqB;;;;;;;EAQ/C,OAAO,yBAAyB;;;;;;;;;;;;;;cAmBrB,qCAAqC;UAKtC;UAJF;UACA;EAGE,YAAA;;IAEN;;EAcE,KAAK,aAAa,SAAS,qBAAqB;EAIhD,KAAK,cAAc,QAAQ;EAkB3B,OAAO,cAAc;;;;MAOvB;;;;EAOJ;;;;EAOA;UAOQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDM,iBAAiB,QAAQ,mBAAmB;;;;;;;;;;;;;iBAqO5C,wBAAwB;;;;;;;iBAUxB,cAAc,eAAe,qBAAqB"}

package/dist/webhook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webhook.d.ts","names":[],"sources":["../src/webhook.ts"],"mappings":";;;;;;UAmDiB;;EAEf;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,WAAW;;;;;;;UAQI;;;;;;;EAOf,KAAK,aAAa,SAAS,qBAAqB;;;;;;;EAQhD,KAAK,cAAc,QAAQ;;;;;;EAO3B,OAAO,cAAc;;;;;UAMN;;EAEf,OAAO;;EAGP;;EAGA;;EAGA;;EAGA,UAAU;;;;;UAMK;;EAEf;;;;;;;;;EAUA,qBAAqB;;EAGrB,aAAa;;EAGb;;;;;UAMe,wBAAwB;;EAEvC,eAAe;;EAGf;;EAGA;;;;;UAMe;;;;;;;;;;;;;;;;;;;EAmBf,KACE,wBACA,WAAW,yBACV;;;;;;;EAQH,SAAS,yBAAyB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,cACE,QAAQ,kBACN,yBAAyB,SAC3B,YAAY,KAAK,wBAAwB,MAAM,UAAU,QAAQ,iBAC1D,MAAM,UAAU,QAAQ;;;;;;;;;EAUjC,WAAW,eAAe,qBAAqB;;;;;;;EAQ/C,OAAO,yBAAyB;;;;;;;;;;;;;;cAmBrB,qCAAqC;UAKtC;UAJF;UACA;EAGE,YAAA;;IAEN;;EAcE,KAAK,aAAa,SAAS,qBAAqB;EAIhD,KAAK,cAAc,QAAQ;EAkB3B,OAAO,cAAc;;;;MAOvB;;;;EAOJ;;;;EAOA;UAOQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDM,iBAAiB,QAAQ,mBAAmB;;;;;;;;;;;;;iBAqO5C,wBAAwB;;;;;;;iBAUxB,cAAc,eAAe,qBAAqB"}

package/dist/webhook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"webhook.js","names":["otelTrace"],"sources":["../src/webhook.ts"],"sourcesContent":["/**\n * Webhook and callback tracing with the \"Parking Lot\" pattern\n *\n * When initiating async operations that return hours/days later (webhooks,\n * payment callbacks, human approvals), you can't keep a span open. This module\n * provides utilities to \"park\" trace context and retrieve it when callbacks arrive.\n *\n * @example Stripe payment webhook\n * ```typescript\n * import { createParkingLot, InMemoryTraceContextStore } from 'autotel/webhook';\n * import { withTracing } from 'autotel';\n *\n * const parkingLot = createParkingLot({\n *   store: new InMemoryTraceContextStore(),\n *   defaultTTLMs: 24 * 60 * 60 * 1000, // 24 hours\n * });\n *\n * // When initiating payment\n * export const initiatePayment = withTracing({})(ctx => async (orderId: string) => {\n *   await parkingLot.park(`payment:${orderId}`, { orderId });\n *   await stripeClient.createPaymentIntent({ metadata: { orderId } });\n * });\n *\n * // When Stripe webhook arrives (hours later)\n * export const handleStripeWebhook = parkingLot.traceCallback({\n *   name: 'stripe.webhook.payment_intent.succeeded',\n *   correlationKeyFrom: (event) => `payment:${event.data.object.metadata.orderId}`,\n * })(ctx => async (event: Stripe.Event) => {\n *   // ctx.parkedContext contains the original trace context\n *   // ctx.elapsedMs shows time since payment was initiated\n *   await fulfillOrder(event.data.object);\n * });\n * ```\n *\n * @module\n */\n\nimport { SpanKind, trace as otelTrace } from '@opentelemetry/api';\nimport type { SpanContext, Link } from '@opentelemetry/api';\nimport { emitCorrelatedEvent } from './correlated-events';\nimport { withTracing } from './functional';\nimport type { AttributeValue, TraceContext } from './trace-context';\nimport { recordStructuredError } from './structured-error';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Stored trace context for parking lot pattern\n */\nexport interface StoredTraceContext {\n  /** Trace ID from the original span */\n  traceId: string;\n\n  /** Span ID from the original span */\n  spanId: string;\n\n  /** Trace flags (sampling decision) */\n  traceFlags: number;\n\n  /** When the context was parked */\n  parkedAt: number;\n\n  /** Optional TTL in milliseconds */\n  ttlMs?: number;\n\n  /** User-provided metadata */\n  metadata?: Record<string, string>;\n}\n\n/**\n * Interface for trace context storage backends\n *\n * Implement this interface to use different storage backends (Redis, DynamoDB, etc.)\n */\nexport interface TraceContextStore {\n  /**\n   * Save trace context with a correlation key\n   *\n   * @param key - Unique correlation key (e.g., \"payment:order-123\")\n   * @param context - The trace context to store\n   */\n  save(key: string, context: StoredTraceContext): Promise<void>;\n\n  /**\n   * Load trace context by correlation key\n   *\n   * @param key - The correlation key used when parking\n   * @returns The stored context, or null if not found/expired\n   */\n  load(key: string): Promise<StoredTraceContext | null>;\n\n  /**\n   * Delete trace context by correlation key\n   *\n   * @param key - The correlation key to delete\n   */\n  delete(key: string): Promise<void>;\n}\n\n/**\n * Configuration for creating a parking lot\n */\nexport interface ParkingLotConfig {\n  /** Storage backend for parked contexts */\n  store: TraceContextStore;\n\n  /** Default TTL in milliseconds (default: 24 hours) */\n  defaultTTLMs?: number;\n\n  /** Prefix for all correlation keys (default: \"parkingLot:\") */\n  keyPrefix?: string;\n\n  /** Whether to auto-delete after retrieval (default: true) */\n  autoDeleteOnRetrieve?: boolean;\n\n  /** Callback when context expires or is not found */\n  onMiss?: (correlationKey: string) => void;\n}\n\n/**\n * Configuration for traceCallback wrapper\n */\nexport interface CallbackConfig {\n  /** Span name for the callback handler */\n  name: string;\n\n  /**\n   * Extract correlation key from callback arguments\n   *\n   * @example\n   * ```typescript\n   * correlationKeyFrom: (event) => `payment:${event.data.orderId}`\n   * ```\n   */\n  correlationKeyFrom: (args: unknown[]) => string;\n\n  /** Additional span attributes */\n  attributes?: Record<string, string | number | boolean>;\n\n  /** Whether to fail if parked context is not found (default: false) */\n  requireParkedContext?: boolean;\n}\n\n/**\n * Extended context for callback handlers\n */\nexport interface CallbackContext extends TraceContext {\n  /** The retrieved parked context, if found */\n  parkedContext: StoredTraceContext | null;\n\n  /** Time elapsed since context was parked (ms), or null if not found */\n  elapsedMs: number | null;\n\n  /** The correlation key used for retrieval */\n  correlationKey: string;\n}\n\n/**\n * The parking lot instance\n */\nexport interface ParkingLot {\n  /**\n   * Park current trace context before initiating async operation\n   *\n   * Call this before sending a webhook, initiating a payment, or starting\n   * any operation that will complete via callback.\n   *\n   * @param correlationKey - Unique key to retrieve context later (e.g., \"payment:order-123\")\n   * @param metadata - Optional metadata to store with the context\n   * @returns The correlation key (with prefix applied)\n   *\n   * @example\n   * ```typescript\n   * await parkingLot.park(`payment:${orderId}`, {\n   *   customerId: customer.id,\n   *   amount: payment.amount.toString(),\n   * });\n   * ```\n   */\n  park(\n    correlationKey: string,\n    metadata?: Record<string, string>,\n  ): Promise<string>;\n\n  /**\n   * Retrieve parked context when callback arrives\n   *\n   * @param correlationKey - The key used when parking\n   * @returns The stored context, or null if not found/expired\n   */\n  retrieve(correlationKey: string): Promise<StoredTraceContext | null>;\n\n  /**\n   * Wrap a callback handler with automatic context retrieval and linking\n   *\n   * Creates a traced function that:\n   * 1. Extracts correlation key from arguments\n   * 2. Retrieves parked context from storage\n   * 3. Creates a span link to the original trace\n   * 4. Provides elapsed time since parking\n   *\n   * @param config - Callback configuration\n   * @returns Factory function for the callback handler\n   *\n   * @example\n   * ```typescript\n   * export const handleWebhook = parkingLot.traceCallback({\n   *   name: 'webhook.payment.completed',\n   *   correlationKeyFrom: (args) => `payment:${args[0].orderId}`,\n   * })(ctx => async (event) => {\n   *   console.log(`Payment completed after ${ctx.elapsedMs}ms`);\n   *   await processPayment(event);\n   * });\n   * ```\n   */\n  traceCallback(\n    config: CallbackConfig,\n  ): <TArgs extends unknown[], TReturn>(\n    fnFactory: (ctx: CallbackContext) => (...args: TArgs) => Promise<TReturn>,\n  ) => (...args: TArgs) => Promise<TReturn>;\n\n  /**\n   * Manually create a span link from stored context\n   *\n   * Useful when you need more control over span creation.\n   *\n   * @param storedContext - The stored trace context\n   * @returns A span link that can be added to a span\n   */\n  createLink(storedContext: StoredTraceContext): Link;\n\n  /**\n   * Check if a parked context exists (without retrieving/deleting it)\n   *\n   * @param correlationKey - The key to check\n   * @returns True if context exists and hasn't expired\n   */\n  exists(correlationKey: string): Promise<boolean>;\n}\n\n// ============================================================================\n// In-Memory Store (for testing and development)\n// ============================================================================\n\n/**\n * In-memory trace context store\n *\n * Useful for testing and development. For production, use a persistent\n * store like Redis or DynamoDB.\n *\n * @example\n * ```typescript\n * const store = new InMemoryTraceContextStore();\n * const parkingLot = createParkingLot({ store });\n * ```\n */\nexport class InMemoryTraceContextStore implements TraceContextStore {\n  private store = new Map<string, StoredTraceContext>();\n  private cleanupInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    private options: {\n      /** Cleanup interval in ms (default: 60000) */\n      cleanupIntervalMs?: number;\n    } = {},\n  ) {\n    // Start periodic cleanup of expired entries\n    const cleanupMs = options.cleanupIntervalMs ?? 60_000;\n    if (cleanupMs > 0) {\n      this.cleanupInterval = setInterval(() => this.cleanup(), cleanupMs);\n      // Don't prevent process exit\n      if (this.cleanupInterval.unref) {\n        this.cleanupInterval.unref();\n      }\n    }\n  }\n\n  async save(key: string, context: StoredTraceContext): Promise<void> {\n    this.store.set(key, context);\n  }\n\n  async load(key: string): Promise<StoredTraceContext | null> {\n    const context = this.store.get(key);\n    if (!context) {\n      return null;\n    }\n\n    // Check TTL expiration\n    if (context.ttlMs) {\n      const age = Date.now() - context.parkedAt;\n      if (age > context.ttlMs) {\n        this.store.delete(key);\n        return null;\n      }\n    }\n\n    return context;\n  }\n\n  async delete(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n\n  /**\n   * Get number of stored contexts (for testing)\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Clear all stored contexts (for testing)\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Stop the cleanup interval\n   */\n  destroy(): void {\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = null;\n    }\n  }\n\n  private cleanup(): void {\n    const now = Date.now();\n    for (const [key, context] of this.store.entries()) {\n      if (context.ttlMs) {\n        const age = now - context.parkedAt;\n        if (age > context.ttlMs) {\n          this.store.delete(key);\n        }\n      }\n    }\n  }\n}\n\n// ============================================================================\n// Parking Lot Factory\n// ============================================================================\n\n/**\n * Create a parking lot for trace context storage and retrieval\n *\n * @param config - Parking lot configuration\n * @returns A parking lot instance\n *\n * @example Basic usage\n * ```typescript\n * const parkingLot = createParkingLot({\n *   store: new InMemoryTraceContextStore(),\n *   defaultTTLMs: 24 * 60 * 60 * 1000, // 24 hours\n * });\n * ```\n *\n * @example With Redis store\n * ```typescript\n * class RedisTraceContextStore implements TraceContextStore {\n *   constructor(private redis: Redis) {}\n *\n *   async save(key: string, context: StoredTraceContext) {\n *     const ttlSeconds = context.ttlMs ? Math.ceil(context.ttlMs / 1000) : 86400;\n *     await this.redis.setex(key, ttlSeconds, JSON.stringify(context));\n *   }\n *\n *   async load(key: string) {\n *     const data = await this.redis.get(key);\n *     return data ? JSON.parse(data) : null;\n *   }\n *\n *   async delete(key: string) {\n *     await this.redis.del(key);\n *   }\n * }\n *\n * const parkingLot = createParkingLot({\n *   store: new RedisTraceContextStore(redis),\n * });\n * ```\n */\nexport function createParkingLot(config: ParkingLotConfig): ParkingLot {\n  const {\n    store,\n    defaultTTLMs = 24 * 60 * 60 * 1000, // 24 hours\n    keyPrefix = 'parkingLot:',\n    autoDeleteOnRetrieve = true,\n    onMiss,\n  } = config;\n\n  /**\n   * Get current span context from active context\n   */\n  function getCurrentSpanContext(): SpanContext | null {\n    const activeSpan = otelTrace.getActiveSpan();\n    if (!activeSpan) {\n      return null;\n    }\n    return activeSpan.spanContext();\n  }\n\n  /**\n   * Apply key prefix\n   */\n  function prefixKey(key: string): string {\n    return `${keyPrefix}${key}`;\n  }\n\n  const parkingLot: ParkingLot = {\n    async park(\n      correlationKey: string,\n      metadata?: Record<string, string>,\n    ): Promise<string> {\n      const spanContext = getCurrentSpanContext();\n      const fullKey = prefixKey(correlationKey);\n\n      const storedContext: StoredTraceContext = {\n        traceId: spanContext?.traceId ?? '',\n        spanId: spanContext?.spanId ?? '',\n        traceFlags: spanContext?.traceFlags ?? 0,\n        parkedAt: Date.now(),\n        ttlMs: defaultTTLMs,\n        metadata,\n      };\n\n      await store.save(fullKey, storedContext);\n\n      const activeSpan = otelTrace.getActiveSpan();\n      if (activeSpan) {\n        const parkAttrs: Record<string, AttributeValue> = {\n          'parking_lot.correlation_key': correlationKey,\n          'parking_lot.ttl_ms': defaultTTLMs,\n          ...(metadata &&\n            Object.fromEntries(\n              Object.entries(metadata).map(([k, v]) => [\n                `parking_lot.metadata.${k}`,\n                v,\n              ]),\n            )),\n        };\n        emitCorrelatedEvent(\n          {\n            setAttribute: (k, v) => activeSpan.setAttribute(k, v),\n            setAttributes: (a) => activeSpan.setAttributes(a),\n            addEvent: (n, a) => activeSpan.addEvent(n, a),\n          },\n          'trace_context_parked',\n          parkAttrs,\n        );\n      }\n\n      // Return the unprefixed key so callers can use the same key for retrieve()\n      return correlationKey;\n    },\n\n    async retrieve(correlationKey: string): Promise<StoredTraceContext | null> {\n      const fullKey = prefixKey(correlationKey);\n      const storedContext = await store.load(fullKey);\n\n      if (!storedContext) {\n        onMiss?.(correlationKey);\n        return null;\n      }\n\n      if (autoDeleteOnRetrieve) {\n        await store.delete(fullKey);\n      }\n\n      return storedContext;\n    },\n\n    traceCallback(\n      callbackConfig: CallbackConfig,\n    ): <TArgs extends unknown[], TReturn>(\n      fnFactory: (ctx: CallbackContext) => (...args: TArgs) => Promise<TReturn>,\n    ) => (...args: TArgs) => Promise<TReturn> {\n      return <TArgs extends unknown[], TReturn>(\n        fnFactory: (\n          ctx: CallbackContext,\n        ) => (...args: TArgs) => Promise<TReturn>,\n      ): ((...args: TArgs) => Promise<TReturn>) => {\n        return withTracing<TArgs, TReturn>({\n          name: callbackConfig.name,\n          spanKind: SpanKind.SERVER,\n        })((baseCtx) => {\n          return async (...args: TArgs) => {\n            // Extract correlation key from arguments\n            const correlationKey = callbackConfig.correlationKeyFrom(args);\n\n            // Retrieve parked context\n            const parkedContext = await parkingLot.retrieve(correlationKey);\n\n            // Calculate elapsed time\n            const elapsedMs = parkedContext\n              ? Date.now() - parkedContext.parkedAt\n              : null;\n\n            // Set span attributes\n            baseCtx.setAttribute('parking_lot.correlation_key', correlationKey);\n\n            if (parkedContext) {\n              baseCtx.setAttribute('parking_lot.elapsed_ms', elapsedMs!);\n              baseCtx.setAttribute(\n                'parking_lot.original_trace_id',\n                parkedContext.traceId,\n              );\n              baseCtx.setAttribute(\n                'parking_lot.original_span_id',\n                parkedContext.spanId,\n              );\n\n              // Add metadata as attributes\n              if (parkedContext.metadata) {\n                for (const [key, value] of Object.entries(\n                  parkedContext.metadata,\n                )) {\n                  baseCtx.setAttribute(`parking_lot.metadata.${key}`, value);\n                }\n              }\n\n              // Create span link to original trace\n              const link = parkingLot.createLink(parkedContext);\n              baseCtx.addLinks([link]);\n\n              emitCorrelatedEvent(baseCtx, 'parked_context_retrieved', {\n                'parking_lot.correlation_key': correlationKey,\n                'parking_lot.elapsed_ms': elapsedMs!,\n                'parking_lot.original_trace_id': parkedContext.traceId,\n              });\n            } else {\n              baseCtx.setAttribute('parking_lot.context_found', false);\n\n              if (callbackConfig.requireParkedContext) {\n                const error = new Error(\n                  `Required parked context not found for key: ${correlationKey}`,\n                );\n                recordStructuredError(baseCtx, error);\n                throw error;\n              }\n            }\n\n            // Apply custom attributes\n            if (callbackConfig.attributes) {\n              for (const [key, value] of Object.entries(\n                callbackConfig.attributes,\n              )) {\n                baseCtx.setAttribute(key, value);\n              }\n            }\n\n            // Create extended context\n            const callbackCtx: CallbackContext = {\n              ...baseCtx,\n              parkedContext,\n              elapsedMs,\n              correlationKey,\n            };\n\n            // Execute user's function\n            const userFn = fnFactory(callbackCtx);\n            return userFn(...args);\n          };\n        }) as (...args: TArgs) => Promise<TReturn>; // async factory always returns a Promise\n      };\n    },\n\n    createLink(storedContext: StoredTraceContext): Link {\n      return {\n        context: {\n          traceId: storedContext.traceId,\n          spanId: storedContext.spanId,\n          traceFlags: storedContext.traceFlags,\n          isRemote: true,\n        },\n        attributes: {\n          'link.type': 'parking_lot',\n          'parking_lot.parked_at': storedContext.parkedAt,\n          ...(storedContext.metadata && {\n            'parking_lot.has_metadata': true,\n          }),\n        },\n      };\n    },\n\n    async exists(correlationKey: string): Promise<boolean> {\n      const fullKey = prefixKey(correlationKey);\n      const context = await store.load(fullKey);\n      return context !== null;\n    },\n  };\n\n  return parkingLot;\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Create a correlation key from multiple parts\n *\n * @param parts - Key parts to join\n * @returns A correlation key string\n *\n * @example\n * ```typescript\n * const key = createCorrelationKey('payment', orderId, 'stripe');\n * // Returns: \"payment:order-123:stripe\"\n * ```\n */\nexport function createCorrelationKey(...parts: (string | number)[]): string {\n  return parts.map(String).join(':');\n}\n\n/**\n * Extract span context from stored context for manual linking\n *\n * @param storedContext - The stored trace context\n * @returns SpanContext compatible object\n */\nexport function toSpanContext(storedContext: StoredTraceContext): SpanContext {\n  return {\n    traceId: storedContext.traceId,\n    spanId: storedContext.spanId,\n    traceFlags: storedContext.traceFlags,\n    isRemote: true,\n  };\n}\n"],"mappings":"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"}

package/dist/workflow-distributed.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-distributed.cjs","names":["createSafeBaggageSchema","withTracing","SpanKind","context"],"sources":["../src/workflow-distributed.ts"],"sourcesContent":["/**\n * Distributed workflow tracing with cross-service correlation\n *\n * Enables tracking workflows that span multiple microservices by propagating\n * workflow identity (workflowId, stepName, stepIndex) via baggage in message headers.\n *\n * Unlike local workflow.ts (which uses AsyncLocalStorage), distributed workflows\n * propagate context across network boundaries using W3C baggage.\n *\n * @example Order fulfillment saga across services\n * ```typescript\n * // Service A: Order Service\n * import { traceDistributedWorkflow, WorkflowBaggage } from 'autotel/workflow-distributed';\n * import { traceProducer } from 'autotel/messaging';\n *\n * export const createOrder = traceDistributedWorkflow({\n *   name: 'OrderFulfillment',\n *   workflowIdFrom: (order) => order.id,\n *   version: '1.0.0',\n * })(ctx => async (order: Order) => {\n *   // Workflow baggage is auto-set\n *   await publishToInventory(order);\n * });\n *\n * const publishToInventory = traceProducer({\n *   system: 'kafka',\n *   destination: 'inventory-requests',\n *   propagateBaggage: true,  // Includes workflow.* baggage\n * })(ctx => async (order) => {\n *   await producer.send({ topic: 'inventory-requests', value: order });\n * });\n *\n * // Service B: Inventory Service\n * import { traceDistributedStep, WorkflowBaggage } from 'autotel/workflow-distributed';\n *\n * export const processInventory = traceDistributedStep({\n *   name: 'ReserveInventory',\n *   extractBaggage: true,  // Extracts workflow.* from headers\n * })(ctx => async (message) => {\n *   const workflow = WorkflowBaggage.get(ctx);\n *   // workflow.workflowId === order.id (propagated from Service A)\n *   console.log(`Processing step for workflow ${workflow.workflowId}`);\n *   await reserveItems(message.items);\n * });\n * ```\n *\n * @module\n */\n\nimport { context, propagation, SpanKind } from '@opentelemetry/api';\nimport { createSafeBaggageSchema } from './business-baggage';\nimport { emitCorrelatedEvent } from './correlated-events';\nimport { withTracing } from './functional';\nimport type { TraceContext } from './trace-context';\n\n// ============================================================================\n// Workflow Baggage Schema\n// ============================================================================\n\n/**\n * Workflow baggage field definitions\n */\nconst workflowBaggageFields = {\n  /** Unique identifier for the workflow instance */\n  workflowId: { type: 'string' as const, maxLength: 128, required: true },\n\n  /** Name/type of the workflow (e.g., \"OrderFulfillment\") */\n  workflowName: { type: 'string' as const, maxLength: 64, required: true },\n\n  /** Version of the workflow definition */\n  workflowVersion: { type: 'string' as const, maxLength: 32 },\n\n  /** Current step name */\n  stepName: { type: 'string' as const, maxLength: 64 },\n\n  /** Current step index (0-based) */\n  stepIndex: { type: 'number' as const },\n\n  /** Total number of steps (if known) */\n  totalSteps: { type: 'number' as const },\n\n  /** Parent workflow ID (for sub-workflows) */\n  parentWorkflowId: { type: 'string' as const, maxLength: 128 },\n\n  /** Correlation ID for external systems */\n  correlationId: { type: 'string' as const, maxLength: 128 },\n\n  /** Workflow priority */\n  priority: {\n    type: 'enum' as const,\n    values: ['low', 'normal', 'high', 'critical'] as const,\n  },\n\n  /** Initiating user/system */\n  initiatedBy: { type: 'string' as const, maxLength: 64 },\n\n  /** Workflow start timestamp (ISO) */\n  startedAt: { type: 'string' as const, maxLength: 30 },\n} as const;\n\n/**\n * Pre-built baggage schema for distributed workflows\n *\n * Use this to read/write workflow context that propagates across services.\n *\n * @example Setting workflow baggage\n * ```typescript\n * WorkflowBaggage.set(ctx, {\n *   workflowId: 'order-12345',\n *   workflowName: 'OrderFulfillment',\n *   stepName: 'ReserveInventory',\n *   stepIndex: 1,\n * });\n * ```\n *\n * @example Reading workflow baggage in downstream service\n * ```typescript\n * const { workflowId, workflowName, stepIndex } = WorkflowBaggage.get(ctx);\n * console.log(`Processing ${workflowName} step ${stepIndex}`);\n * ```\n */\nexport const WorkflowBaggage = createSafeBaggageSchema(workflowBaggageFields, {\n  prefix: 'workflow',\n  hashHighCardinality: false, // Workflow IDs should be traceable\n  redactPII: false, // Workflow fields are internal identifiers\n});\n\n/**\n * Type for workflow baggage values\n */\nexport type WorkflowBaggageValues = {\n  workflowId: string;\n  workflowName: string;\n  workflowVersion?: string;\n  stepName?: string;\n  stepIndex?: number;\n  totalSteps?: number;\n  parentWorkflowId?: string;\n  correlationId?: string;\n  priority?: 'low' | 'normal' | 'high' | 'critical';\n  initiatedBy?: string;\n  startedAt?: string;\n};\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Configuration for distributed workflow tracing\n */\nexport interface DistributedWorkflowConfig {\n  /** Workflow name/type (e.g., \"OrderFulfillment\", \"UserOnboarding\") */\n  name: string;\n\n  /**\n   * Extract workflow ID from function arguments\n   *\n   * Receives all arguments passed to the workflow function, allowing\n   * multi-parameter handlers to derive workflow IDs from any argument.\n   *\n   * @example Single argument\n   * ```typescript\n   * workflowIdFrom: (order) => order.id\n   * ```\n   *\n   * @example Multiple arguments (payload + metadata)\n   * ```typescript\n   * workflowIdFrom: (payload, metadata) => metadata.correlationId ?? payload.id\n   * ```\n   */\n  workflowIdFrom: (...args: unknown[]) => string;\n\n  /** Workflow version (e.g., \"1.0.0\", \"2023-01-15\") */\n  version?: string;\n\n  /** Total number of steps if known */\n  totalSteps?: number;\n\n  /** Parent workflow ID (for sub-workflows) */\n  parentWorkflowId?: string;\n\n  /** Correlation ID for external systems */\n  correlationId?: string;\n\n  /** Workflow priority */\n  priority?: 'low' | 'normal' | 'high' | 'critical';\n\n  /** User/system that initiated the workflow */\n  initiatedBy?: string;\n\n  /** Additional span attributes */\n  attributes?: Record<string, string | number | boolean>;\n\n  /** Callback on workflow start */\n  onStart?: (ctx: DistributedWorkflowContext) => void;\n\n  /** Callback on workflow completion */\n  onComplete?: (ctx: DistributedWorkflowContext, result: unknown) => void;\n\n  /** Callback on workflow error */\n  onError?: (ctx: DistributedWorkflowContext, error: Error) => void;\n}\n\n/**\n * Configuration for distributed workflow step\n */\nexport interface DistributedStepConfig {\n  /** Step name (e.g., \"ReserveInventory\", \"ChargePayment\") */\n  name: string;\n\n  /**\n   * Extract baggage from incoming message/request\n   *\n   * If true, reads workflow baggage from current context (assumes already extracted).\n   * If function, extracts from arguments.\n   *\n   * @default true\n   */\n  extractBaggage?:\n    boolean | ((args: unknown[]) => WorkflowBaggageValues | null);\n\n  /** Override step index (otherwise uses baggage or auto-increments) */\n  stepIndex?: number;\n\n  /** Additional span attributes */\n  attributes?: Record<string, string | number | boolean>;\n\n  /** Whether this step is idempotent (safe to retry) */\n  idempotent?: boolean;\n\n  /** Whether this step is a compensation/rollback step */\n  isCompensation?: boolean;\n\n  /** Callback on step start */\n  onStart?: (ctx: DistributedStepContext) => void;\n\n  /** Callback on step completion */\n  onComplete?: (ctx: DistributedStepContext, result: unknown) => void;\n\n  /** Callback on step error */\n  onError?: (ctx: DistributedStepContext, error: Error) => void;\n}\n\n/**\n * Extended context for distributed workflow root\n */\nexport interface DistributedWorkflowContext extends TraceContext {\n  /** The workflow ID */\n  workflowId: string;\n\n  /** The workflow name */\n  workflowName: string;\n\n  /** The workflow version */\n  workflowVersion?: string;\n\n  /** Get workflow baggage for propagation to other services */\n  getWorkflowBaggage(): WorkflowBaggageValues;\n\n  /** Set additional workflow baggage fields */\n  setWorkflowBaggage(values: Partial<WorkflowBaggageValues>): void;\n\n  /** Get headers with workflow baggage for outgoing requests */\n  getWorkflowHeaders(): Record<string, string>;\n\n  /** Record workflow step completion (for progress tracking) */\n  recordStepProgress(stepName: string, stepIndex: number): void;\n}\n\n/**\n * Extended context for distributed workflow step\n */\nexport interface DistributedStepContext extends TraceContext {\n  /** The workflow ID (from baggage) */\n  workflowId: string | null;\n\n  /** The workflow name (from baggage) */\n  workflowName: string | null;\n\n  /** The current step name */\n  stepName: string;\n\n  /** The current step index */\n  stepIndex: number | null;\n\n  /** Whether this step is a compensation */\n  isCompensation: boolean;\n\n  /** Get the full workflow baggage */\n  getWorkflowBaggage(): WorkflowBaggageValues | null;\n\n  /** Update workflow baggage (e.g., increment step index) */\n  updateWorkflowBaggage(values: Partial<WorkflowBaggageValues>): void;\n\n  /** Get headers with updated workflow baggage for downstream calls */\n  getWorkflowHeaders(): Record<string, string>;\n\n  /** Mark step as requiring compensation on failure */\n  requiresCompensation(compensationData?: Record<string, unknown>): void;\n}\n\n// ============================================================================\n// Distributed Workflow Tracer\n// ============================================================================\n\n/**\n * Create a traced distributed workflow function\n *\n * Wraps a function as the entry point for a distributed workflow. Automatically:\n * - Generates or extracts workflow ID\n * - Sets workflow baggage for downstream propagation\n * - Creates root span with workflow attributes\n *\n * @param config - Workflow configuration\n * @returns Factory function for the workflow handler\n *\n * @example Basic usage\n * ```typescript\n * export const createOrder = traceDistributedWorkflow({\n *   name: 'OrderFulfillment',\n *   workflowIdFrom: (order) => order.id,\n *   version: '1.0.0',\n * })(ctx => async (order: Order) => {\n *   ctx.recordStepProgress('ValidateOrder', 0);\n *   await validateOrder(order);\n *\n *   ctx.recordStepProgress('ReserveInventory', 1);\n *   await publishToInventoryService(order);\n *\n *   return { workflowId: ctx.workflowId, status: 'started' };\n * });\n * ```\n */\nexport function traceDistributedWorkflow(config: DistributedWorkflowConfig) {\n  const spanName = `workflow.${config.name}`;\n\n  return <TArgs extends unknown[], TReturn>(\n    fnFactory: (\n      ctx: DistributedWorkflowContext,\n    ) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return withTracing<TArgs, TReturn>({\n      name: spanName,\n      spanKind: SpanKind.INTERNAL,\n    })((baseCtx) => {\n      return async (...args: TArgs) => {\n        // Extract workflow ID from arguments (spread to allow multi-arg access)\n        const workflowId = config.workflowIdFrom(...args);\n        const startedAt = new Date().toISOString();\n\n        // Initialize workflow baggage\n        const baggageValues: WorkflowBaggageValues = {\n          workflowId,\n          workflowName: config.name,\n          workflowVersion: config.version,\n          stepIndex: 0,\n          totalSteps: config.totalSteps,\n          parentWorkflowId: config.parentWorkflowId,\n          correlationId: config.correlationId,\n          priority: config.priority,\n          initiatedBy: config.initiatedBy,\n          startedAt,\n        };\n\n        // Set baggage\n        WorkflowBaggage.set(baseCtx, baggageValues);\n\n        // Set span attributes\n        baseCtx.setAttribute('workflow.id', workflowId);\n        baseCtx.setAttribute('workflow.name', config.name);\n        if (config.version) {\n          baseCtx.setAttribute('workflow.version', config.version);\n        }\n        if (config.totalSteps) {\n          baseCtx.setAttribute('workflow.total_steps', config.totalSteps);\n        }\n        if (config.parentWorkflowId) {\n          baseCtx.setAttribute('workflow.parent_id', config.parentWorkflowId);\n        }\n        if (config.priority) {\n          baseCtx.setAttribute('workflow.priority', config.priority);\n        }\n        if (config.initiatedBy) {\n          baseCtx.setAttribute('workflow.initiated_by', config.initiatedBy);\n        }\n        baseCtx.setAttribute('workflow.started_at', startedAt);\n\n        // Apply custom attributes\n        if (config.attributes) {\n          for (const [key, value] of Object.entries(config.attributes)) {\n            baseCtx.setAttribute(key, value);\n          }\n        }\n\n        // Create extended context\n        const workflowCtx: DistributedWorkflowContext = {\n          ...baseCtx,\n          workflowId,\n          workflowName: config.name,\n          workflowVersion: config.version,\n\n          getWorkflowBaggage(): WorkflowBaggageValues {\n            return { ...baggageValues };\n          },\n\n          setWorkflowBaggage(values: Partial<WorkflowBaggageValues>): void {\n            Object.assign(baggageValues, values);\n            WorkflowBaggage.set(baseCtx, baggageValues);\n          },\n\n          getWorkflowHeaders(): Record<string, string> {\n            const headers: Record<string, string> = {};\n            const ctx = context.active();\n            propagation.inject(ctx, headers);\n            return headers;\n          },\n\n          recordStepProgress(stepName: string, stepIndex: number): void {\n            baggageValues.stepName = stepName;\n            baggageValues.stepIndex = stepIndex;\n            WorkflowBaggage.set(baseCtx, baggageValues);\n\n            emitCorrelatedEvent(baseCtx, 'workflow.step_progress', {\n              'workflow.step.name': stepName,\n              'workflow.step.index': stepIndex,\n            });\n          },\n        };\n\n        // Call onStart callback\n        config.onStart?.(workflowCtx);\n\n        // Add start event\n        emitCorrelatedEvent(baseCtx, 'workflow.started', {\n          'workflow.id': workflowId,\n          'workflow.name': config.name,\n        });\n\n        try {\n          const userFn = fnFactory(workflowCtx);\n          const result = await userFn(...args);\n\n          // Call onComplete callback\n          config.onComplete?.(workflowCtx, result);\n\n          // Add completion event\n          emitCorrelatedEvent(baseCtx, 'workflow.completed', {\n            'workflow.id': workflowId,\n          });\n\n          return result;\n        } catch (error) {\n          // Call onError callback\n          config.onError?.(workflowCtx, error as Error);\n\n          // Add error event\n          emitCorrelatedEvent(baseCtx, 'workflow.failed', {\n            'workflow.id': workflowId,\n            'workflow.error': (error as Error).message,\n          });\n\n          throw error;\n        }\n      };\n    }) as (...args: TArgs) => Promise<TReturn>; // async factory always returns a Promise\n  };\n}\n\n// ============================================================================\n// Distributed Step Tracer\n// ============================================================================\n\n/**\n * Create a traced distributed workflow step\n *\n * Use in downstream services to trace steps that are part of a distributed workflow.\n * Automatically extracts workflow baggage from the current context.\n *\n * @param config - Step configuration\n * @returns Factory function for the step handler\n *\n * @example Consumer in downstream service\n * ```typescript\n * export const processInventory = traceConsumer({\n *   system: 'kafka',\n *   destination: 'inventory-requests',\n *   extractBaggage: true,  // Extracts workflow.* from headers\n * })(ctx => {\n *   // Wrap inner logic with traceDistributedStep\n *   return traceDistributedStep({\n *     name: 'ReserveInventory',\n *   })(stepCtx => async (message) => {\n *     console.log(`Processing workflow ${stepCtx.workflowId}`);\n *     await reserveItems(message.items);\n *   })(message);\n * });\n * ```\n *\n * @example Standalone step handler\n * ```typescript\n * export const reserveInventory = traceDistributedStep({\n *   name: 'ReserveInventory',\n *   idempotent: true,\n * })(ctx => async (request: InventoryRequest) => {\n *   if (ctx.workflowId) {\n *     console.log(`Part of workflow ${ctx.workflowId}, step ${ctx.stepIndex}`);\n *   }\n *   return await inventoryService.reserve(request.items);\n * });\n * ```\n */\nexport function traceDistributedStep(config: DistributedStepConfig) {\n  const spanName = `workflow.step.${config.name}`;\n\n  return <TArgs extends unknown[], TReturn>(\n    fnFactory: (\n      ctx: DistributedStepContext,\n    ) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return withTracing<TArgs, TReturn>({\n      name: spanName,\n      spanKind: SpanKind.INTERNAL,\n    })((baseCtx) => {\n      return async (...args: TArgs) => {\n        // Extract workflow baggage\n        let baggageValues: WorkflowBaggageValues | null = null;\n\n        const extractBaggage = config.extractBaggage ?? true;\n        if (typeof extractBaggage === 'function') {\n          baggageValues = extractBaggage(args);\n        } else if (extractBaggage) {\n          // Read from current context\n          const extracted = WorkflowBaggage.get(baseCtx);\n          if (extracted.workflowId && extracted.workflowName) {\n            baggageValues = extracted as WorkflowBaggageValues;\n          }\n        }\n\n        // Determine step index\n        // If explicit stepIndex provided in config, use it\n        // Otherwise, auto-increment from baggage if available\n        let stepIndex: number | null;\n        if (config.stepIndex !== undefined) {\n          stepIndex = config.stepIndex;\n        } else if (baggageValues?.stepIndex === undefined) {\n          stepIndex = null;\n        } else {\n          // Auto-increment from previous step\n          stepIndex = baggageValues.stepIndex + 1;\n        }\n\n        // Update baggage with current step\n        if (baggageValues) {\n          baggageValues.stepName = config.name;\n          if (stepIndex !== null) {\n            baggageValues.stepIndex = stepIndex;\n          }\n          WorkflowBaggage.set(baseCtx, baggageValues);\n        }\n\n        // Set span attributes\n        baseCtx.setAttribute('workflow.step.name', config.name);\n        if (stepIndex !== null) {\n          baseCtx.setAttribute('workflow.step.index', stepIndex);\n        }\n        if (config.idempotent !== undefined) {\n          baseCtx.setAttribute('workflow.step.idempotent', config.idempotent);\n        }\n        if (config.isCompensation) {\n          baseCtx.setAttribute('workflow.step.is_compensation', true);\n        }\n\n        // Add workflow context attributes if available\n        if (baggageValues) {\n          baseCtx.setAttribute('workflow.id', baggageValues.workflowId);\n          baseCtx.setAttribute('workflow.name', baggageValues.workflowName);\n          if (baggageValues.workflowVersion) {\n            baseCtx.setAttribute(\n              'workflow.version',\n              baggageValues.workflowVersion,\n            );\n          }\n          if (baggageValues.totalSteps) {\n            baseCtx.setAttribute(\n              'workflow.total_steps',\n              baggageValues.totalSteps,\n            );\n          }\n        }\n\n        // Apply custom attributes\n        if (config.attributes) {\n          for (const [key, value] of Object.entries(config.attributes)) {\n            baseCtx.setAttribute(key, value);\n          }\n        }\n\n        // Compensation data storage\n        let compensationData: Record<string, unknown> | undefined;\n\n        // Create extended context\n        const stepCtx: DistributedStepContext = {\n          ...baseCtx,\n          workflowId: baggageValues?.workflowId ?? null,\n          workflowName: baggageValues?.workflowName ?? null,\n          stepName: config.name,\n          stepIndex,\n          isCompensation: config.isCompensation ?? false,\n\n          getWorkflowBaggage(): WorkflowBaggageValues | null {\n            return baggageValues ? { ...baggageValues } : null;\n          },\n\n          updateWorkflowBaggage(values: Partial<WorkflowBaggageValues>): void {\n            if (baggageValues) {\n              Object.assign(baggageValues, values);\n              WorkflowBaggage.set(baseCtx, baggageValues);\n            }\n          },\n\n          getWorkflowHeaders(): Record<string, string> {\n            const headers: Record<string, string> = {};\n            const ctx = context.active();\n            propagation.inject(ctx, headers);\n            return headers;\n          },\n\n          requiresCompensation(data?: Record<string, unknown>): void {\n            compensationData = data;\n            baseCtx.setAttribute('workflow.step.requires_compensation', true);\n            emitCorrelatedEvent(\n              baseCtx,\n              'workflow.step.compensation_registered',\n              {\n                'workflow.step.name': config.name,\n                ...(data && {\n                  'workflow.step.compensation_data': JSON.stringify(data),\n                }),\n              },\n            );\n          },\n        };\n\n        // Call onStart callback\n        config.onStart?.(stepCtx);\n\n        // Add start event\n        emitCorrelatedEvent(baseCtx, 'workflow.step.started', {\n          'workflow.step.name': config.name,\n          ...(baggageValues && { 'workflow.id': baggageValues.workflowId }),\n        });\n\n        try {\n          const userFn = fnFactory(stepCtx);\n          const result = await userFn(...args);\n\n          // Call onComplete callback\n          config.onComplete?.(stepCtx, result);\n\n          // Add completion event\n          emitCorrelatedEvent(baseCtx, 'workflow.step.completed', {\n            'workflow.step.name': config.name,\n          });\n\n          return result;\n        } catch (error) {\n          // Call onError callback\n          config.onError?.(stepCtx, error as Error);\n\n          // Add error event with compensation info if registered\n          emitCorrelatedEvent(baseCtx, 'workflow.step.failed', {\n            'workflow.step.name': config.name,\n            'workflow.step.error': (error as Error).message,\n            ...(compensationData && {\n              'workflow.step.requires_compensation': true,\n            }),\n          });\n\n          throw error;\n        }\n      };\n    }) as (...args: TArgs) => Promise<TReturn>; // async factory always returns a Promise\n  };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Generate a unique workflow ID\n *\n * @param prefix - Optional prefix for the ID\n * @returns A unique workflow ID\n *\n * @example\n * ```typescript\n * const workflowId = generateWorkflowId('order'); // \"order-abc123def456\"\n * ```\n */\nexport function generateWorkflowId(prefix?: string): string {\n  const random = Math.random().toString(36).slice(2, 15);\n  const timestamp = Date.now().toString(36);\n  const id = `${timestamp}-${random}`;\n  return prefix ? `${prefix}-${id}` : id;\n}\n\n/**\n * Check if the current context is part of a distributed workflow\n *\n * @param ctx - The trace context\n * @returns True if workflow baggage is present\n */\nexport function isInDistributedWorkflow(ctx: TraceContext): boolean {\n  const baggage = WorkflowBaggage.get(ctx);\n  return !!(baggage.workflowId && baggage.workflowName);\n}\n\n/**\n * Get workflow progress information\n *\n * @param ctx - The trace context\n * @returns Progress info or null if not in a workflow\n */\nexport function getWorkflowProgress(ctx: TraceContext): {\n  workflowId: string;\n  workflowName: string;\n  currentStep: string | null;\n  currentStepIndex: number | null;\n  totalSteps: number | null;\n  percentComplete: number | null;\n} | null {\n  const baggage = WorkflowBaggage.get(ctx);\n  if (!baggage.workflowId || !baggage.workflowName) {\n    return null;\n  }\n\n  const percentComplete =\n    baggage.totalSteps && baggage.stepIndex !== undefined\n      ? Math.round(((baggage.stepIndex + 1) / baggage.totalSteps) * 100)\n      : null;\n\n  return {\n    workflowId: baggage.workflowId,\n    workflowName: baggage.workflowName,\n    currentStep: baggage.stepName ?? null,\n    currentStepIndex: baggage.stepIndex ?? null,\n    totalSteps: baggage.totalSteps ?? null,\n    percentComplete,\n  };\n}\n\n/**\n * Create workflow correlation headers for manual propagation\n *\n * Use when you need to manually add workflow context to outgoing requests.\n *\n * @param values - Workflow baggage values\n * @returns Headers object with workflow baggage\n *\n * @example\n * ```typescript\n * const headers = createWorkflowHeaders({\n *   workflowId: 'order-123',\n *   workflowName: 'OrderFulfillment',\n *   stepIndex: 2,\n * });\n *\n * await fetch('/api/inventory', { headers });\n * ```\n */\nexport function createWorkflowHeaders(\n  values: Partial<WorkflowBaggageValues>,\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n\n  // Build baggage string\n  const baggageEntries: string[] = [];\n\n  if (values.workflowId) {\n    baggageEntries.push(\n      `workflow.workflowId=${encodeURIComponent(values.workflowId)}`,\n    );\n  }\n  if (values.workflowName) {\n    baggageEntries.push(\n      `workflow.workflowName=${encodeURIComponent(values.workflowName)}`,\n    );\n  }\n  if (values.workflowVersion) {\n    baggageEntries.push(\n      `workflow.workflowVersion=${encodeURIComponent(values.workflowVersion)}`,\n    );\n  }\n  if (values.stepName) {\n    baggageEntries.push(\n      `workflow.stepName=${encodeURIComponent(values.stepName)}`,\n    );\n  }\n  if (values.stepIndex !== undefined) {\n    baggageEntries.push(`workflow.stepIndex=${values.stepIndex}`);\n  }\n  if (values.totalSteps !== undefined) {\n    baggageEntries.push(`workflow.totalSteps=${values.totalSteps}`);\n  }\n  if (values.priority) {\n    baggageEntries.push(`workflow.priority=${values.priority}`);\n  }\n  if (values.correlationId) {\n    baggageEntries.push(\n      `workflow.correlationId=${encodeURIComponent(values.correlationId)}`,\n    );\n  }\n  if (values.parentWorkflowId) {\n    baggageEntries.push(\n      `workflow.parentWorkflowId=${encodeURIComponent(values.parentWorkflowId)}`,\n    );\n  }\n  if (values.initiatedBy) {\n    baggageEntries.push(\n      `workflow.initiatedBy=${encodeURIComponent(values.initiatedBy)}`,\n    );\n  }\n  if (values.startedAt) {\n    baggageEntries.push(\n      `workflow.startedAt=${encodeURIComponent(values.startedAt)}`,\n    );\n  }\n\n  if (baggageEntries.length > 0) {\n    headers['baggage'] = baggageEntries.join(',');\n  }\n\n  return headers;\n}\n\n/**\n * Parse workflow context from baggage header\n *\n * @param baggageHeader - The baggage header value\n * @returns Parsed workflow values or null\n */\nexport function parseWorkflowFromBaggage(\n  baggageHeader: string,\n): Partial<WorkflowBaggageValues> | null {\n  if (!baggageHeader) {\n    return null;\n  }\n\n  const values: Partial<WorkflowBaggageValues> = {};\n  const entries = baggageHeader.split(',');\n\n  for (const entry of entries) {\n    const [key, value] = entry.trim().split('=');\n    if (!key || !value) continue;\n\n    const decodedValue = decodeURIComponent(value);\n\n    switch (key) {\n      case 'workflow.workflowId': {\n        values.workflowId = decodedValue;\n        break;\n      }\n      case 'workflow.workflowName': {\n        values.workflowName = decodedValue;\n        break;\n      }\n      case 'workflow.workflowVersion': {\n        values.workflowVersion = decodedValue;\n        break;\n      }\n      case 'workflow.stepName': {\n        values.stepName = decodedValue;\n        break;\n      }\n      case 'workflow.stepIndex': {\n        values.stepIndex = Number.parseInt(decodedValue, 10);\n        break;\n      }\n      case 'workflow.totalSteps': {\n        values.totalSteps = Number.parseInt(decodedValue, 10);\n        break;\n      }\n      case 'workflow.priority': {\n        values.priority = decodedValue as WorkflowBaggageValues['priority'];\n        break;\n      }\n      case 'workflow.correlationId': {\n        values.correlationId = decodedValue;\n        break;\n      }\n      case 'workflow.parentWorkflowId': {\n        values.parentWorkflowId = decodedValue;\n        break;\n      }\n      case 'workflow.initiatedBy': {\n        values.initiatedBy = decodedValue;\n        break;\n      }\n      case 'workflow.startedAt': {\n        values.startedAt = decodedValue;\n        break;\n      }\n    }\n  }\n\n  return Object.keys(values).length > 0 ? values : null;\n}\n"],"mappings":"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"}

package/dist/workflow-distributed.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-distributed.d.cts","names":[],"sources":["../src/workflow-distributed.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cAyHa,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASD;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;UAUe;;EAEf;;;;;;;;;;;;;;;;;EAkBA,oBAAoB;;EAGpB;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,aAAa;;EAGb,WAAW,KAAK;;EAGhB,cAAc,KAAK,4BAA4B;;EAG/C,WAAW,KAAK,4BAA4B,OAAO;;;;;UAMpC;;EAEf;;;;;;;;;EAUA,6BACc,oBAAoB;;EAGlC;;EAGA,aAAa;;EAGb;;EAGA;;EAGA,WAAW,KAAK;;EAGhB,cAAc,KAAK,wBAAwB;;EAG3C,WAAW,KAAK,wBAAwB,OAAO;;;;;UAMhC,mCAAmC;;EAElD;;EAGA;;EAGA;;EAGA,sBAAsB;;EAGtB,mBAAmB,QAAQ,QAAQ;;EAGnC,sBAAsB;;EAGtB,mBAAmB,kBAAkB;;;;;UAMtB,+BAA+B;;EAE9C;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,sBAAsB;;EAGtB,sBAAsB,QAAQ,QAAQ;;EAGtC,sBAAsB;;EAGtB,qBAAqB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC1B,yBAAyB,QAAQ,6BAGvC,yBAAyB,SAC/B,YACE,KAAK,mCACE,MAAM,UAAU,QAAQ,kBAC3B,MAAM,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2KlB,qBAAqB,QAAQ,yBAGnC,yBAAyB,SAC/B,YACE,KAAK,+BACE,MAAM,UAAU,QAAQ,kBAC3B,MAAM,UAAU,QAAQ;;;;;;;;;;;;iBAsLlB,mBAAmB;;;;;;;iBAanB,wBAAwB,KAAK;;;;;;;iBAW7B,oBAAoB,KAAK;EACvC;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;iBAyCc,sBACd,QAAQ,QAAQ,yBACf;;;;;;;iBAqEa,yBACd,wBACC,QAAQ"}

package/dist/workflow-distributed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-distributed.d.ts","names":[],"sources":["../src/workflow-distributed.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cAyHa,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASD;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;UAUe;;EAEf;;;;;;;;;;;;;;;;;EAkBA,oBAAoB;;EAGpB;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,aAAa;;EAGb,WAAW,KAAK;;EAGhB,cAAc,KAAK,4BAA4B;;EAG/C,WAAW,KAAK,4BAA4B,OAAO;;;;;UAMpC;;EAEf;;;;;;;;;EAUA,6BACc,oBAAoB;;EAGlC;;EAGA,aAAa;;EAGb;;EAGA;;EAGA,WAAW,KAAK;;EAGhB,cAAc,KAAK,wBAAwB;;EAG3C,WAAW,KAAK,wBAAwB,OAAO;;;;;UAMhC,mCAAmC;;EAElD;;EAGA;;EAGA;;EAGA,sBAAsB;;EAGtB,mBAAmB,QAAQ,QAAQ;;EAGnC,sBAAsB;;EAGtB,mBAAmB,kBAAkB;;;;;UAMtB,+BAA+B;;EAE9C;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,sBAAsB;;EAGtB,sBAAsB,QAAQ,QAAQ;;EAGtC,sBAAsB;;EAGtB,qBAAqB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC1B,yBAAyB,QAAQ,6BAGvC,yBAAyB,SAC/B,YACE,KAAK,mCACE,MAAM,UAAU,QAAQ,kBAC3B,MAAM,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2KlB,qBAAqB,QAAQ,yBAGnC,yBAAyB,SAC/B,YACE,KAAK,+BACE,MAAM,UAAU,QAAQ,kBAC3B,MAAM,UAAU,QAAQ;;;;;;;;;;;;iBAsLlB,mBAAmB;;;;;;;iBAanB,wBAAwB,KAAK;;;;;;;iBAW7B,oBAAoB,KAAK;EACvC;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;iBAyCc,sBACd,QAAQ,QAAQ,yBACf;;;;;;;iBAqEa,yBACd,wBACC,QAAQ"}