autotel 4.2.0 → 4.2.1

package/dist/logger.cjs

@@ -1,10 +1,238 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_logger = require('./logger-thMPLpOG.cjs');
 
-exports.LOG_LEVEL = require_logger.LOG_LEVEL;
-exports.LoggedOperation = require_logger.LoggedOperation;
-exports.autotelLogger = require_logger.autotelLogger;
-exports.createBuiltinLogger = require_logger.createBuiltinLogger;
-exports.getActiveLogLevel = require_logger.getActiveLogLevel;
-exports.getTraceContext = require_logger.getTraceContext;
-exports.runWithLogLevel = require_logger.runWithLogLevel;
+//#region src/logger.ts
+/**
+* Logger types and utilities for autotel
+*
+* **Zero-Config Option:** Don't provide a logger to `init()` and autotel uses
+* a built-in structured JSON logger with automatic trace context injection.
+*
+* **BYOL (Bring Your Own Logger):** Pass Pino or Bunyan to `init()` for
+* automatic instrumentation with trace context and OTLP log export.
+*
+* ## Logger Signature
+*
+* Autotel v2.10+ uses **Pino's signature**: `logger.info({ metadata }, 'message')`.
+*
+* ### Backward Compatibility
+*
+* The built-in logger auto-detects legacy Winston-style calls and swaps arguments:
+* ```typescript
+* // Legacy (auto-detected and handled)
+* logger.info('User created', { userId: '123' });
+* // → Internally treated as: logger.info({ userId: '123' }, 'User created')
+* // → Logs warning in development, works silently in production
+* ```
+*
+* ### Recommended Usage
+*
+* ```typescript
+* // ✅ Pino-style (preferred)
+* logger.info({ userId: '123' }, 'User created');
+*
+* // ✅ Simple message (no metadata)
+* logger.info('Server started');
+* ```
+*
+* **Note:** If you BYOL (bring your own logger), it must use Pino signature.
+* Winston and other `(message, meta)` loggers are NOT compatible.
+* For Winston, use `@opentelemetry/instrumentation-winston` instead.
+*
+* @example Zero-config (uses built-in logger)
+* ```typescript
+* import { init } from 'autotel';
+*
+* init({ service: 'my-app' });
+* // Internal logs: {"level":"info","service":"my-app","msg":"...","traceId":"..."}
+* ```
+*
+* @example Using built-in logger directly
+* ```typescript
+* import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';
+*
+* const log = createBuiltinLogger('my-service');
+*
+* // Simple message (no metadata)
+* log.info('Server started');
+*
+* // With metadata (Pino-style: object first, message second)
+* log.info({ userId: '123' }, 'User created');
+* // Output: {"level":"info","service":"my-service","msg":"User created","userId":"123","traceId":"..."}
+*
+* // Dynamic log level per-request
+* runWithLogLevel('debug', () => {
+*   log.debug('Debug info for this request only');
+* });
+* ```
+*
+* @example Using Pino (recommended for production, auto-instrumented)
+* ```typescript
+* import pino from 'pino';  // npm install pino
+* import { init } from 'autotel';
+*
+* const logger = pino({ level: 'info' });
+* init({ service: 'my-app', logger });
+*
+* // Logs automatically include traceId/spanId and export via OTLP!
+* logger.info({ userId: '123' }, 'User created');
+* ```
+*
+* @example Using Bunyan (auto-instrumented, same signature as Pino)
+* ```typescript
+* import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan
+* import { init } from 'autotel';
+* import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';
+*
+* const logger = bunyan.createLogger({ name: 'my-app' });
+* init({
+*   service: 'my-app',
+*   logger,
+*   instrumentations: [new BunyanInstrumentation()]
+* });
+* ```
+*
+* @example Custom logger (MUST use Pino-compatible signature)
+* ```typescript
+* // ⚠️ Your custom logger MUST accept (object, message?) signature
+* const logger = {
+*   info: (extra, msg) => console.log(msg || '', extra),
+*   warn: (extra, msg) => console.warn(msg || '', extra),
+*   error: (extra, msg) => console.error(msg || '', extra),
+*   debug: (extra, msg) => console.debug(msg || '', extra),
+* };
+* init({ service: 'my-app', logger });
+* ```
+*
+* @example BYOL helper: inject trace context into any logger
+* ```typescript
+* import bunyan from 'bunyan';
+* import { getTraceContext } from 'autotel/logger';
+*
+* const bunyanLogger = bunyan.createLogger({ name: 'myapp' });
+* const ctx = getTraceContext();
+* bunyanLogger.info({ ...ctx, userId: '123' }, 'Creating user');
+* ```
+*/
+/**
+* Log level constants
+*/
+const LOG_LEVEL = {
+	DEBUG: "debug",
+	INFO: "info",
+	WARN: "warn",
+	ERROR: "error"
+};
+/**
+* TS5+ Standard Decorator for logging and tracing operations
+* Uses TC39 Stage 3 decorator syntax
+*
+* This is the traditional per-method decorator approach.
+* For zero-boilerplate solution, see @Instrumented class decorator.
+*
+* @example
+* // Simple usage (Pino-style: object first, message second)
+* class OrderService {
+*   constructor(private readonly deps: { log: Logger }) {}
+*
+*   @LoggedOperation('order.create')
+*   async createOrder(data: CreateOrderData) {
+*     // ✅ Correct Pino-style logging
+*     this.deps.log.info({ orderId: data.id }, 'Creating order');
+*   }
+* }
+*
+* // Advanced usage (future-proof for options)
+* @LoggedOperation({ operationName: 'order.create' })
+* async createOrder(data: CreateOrderData) { }
+*/
+function LoggedOperation(operationNameOrOptions) {
+	const operationName = typeof operationNameOrOptions === "string" ? operationNameOrOptions : operationNameOrOptions.operationName;
+	return function(originalMethod, context) {
+		const methodName = String(context.name);
+		return async function(...args) {
+			const log = this.deps?.log;
+			const startTime = performance.now();
+			return getConfig().tracer.startActiveSpan(operationName, async (span) => {
+				try {
+					log?.info({
+						operation: operationName,
+						method: methodName,
+						args
+					}, "Operation started");
+					const result = await originalMethod.apply(this, args);
+					const duration = performance.now() - startTime;
+					log?.info({
+						operation: operationName,
+						method: methodName,
+						duration
+					}, "Operation completed");
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.setAttributes({
+						"operation.name": operationName,
+						"operation.method": methodName,
+						"operation.duration": duration,
+						"operation.success": true
+					});
+					return result;
+				} catch (error) {
+					const duration = performance.now() - startTime;
+					log?.error({
+						err: error instanceof Error ? error : void 0,
+						operation: operationName,
+						method: methodName,
+						duration
+					}, "Operation failed");
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : "Unknown error"
+					});
+					span.setAttributes({
+						"operation.name": operationName,
+						"operation.method": methodName,
+						"operation.duration": duration,
+						"operation.success": false,
+						"error.type": error instanceof Error ? error.constructor.name : "Unknown"
+					});
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+	};
+}
+
+//#endregion
+exports.LOG_LEVEL = LOG_LEVEL;
+exports.LoggedOperation = LoggedOperation;
+Object.defineProperty(exports, 'autotelLogger', {
+  enumerable: true,
+  get: function () {
+    return autotelLogger;
+  }
+});
+Object.defineProperty(exports, 'createBuiltinLogger', {
+  enumerable: true,
+  get: function () {
+    return createBuiltinLogger;
+  }
+});
+Object.defineProperty(exports, 'getActiveLogLevel', {
+  enumerable: true,
+  get: function () {
+    return getActiveLogLevel;
+  }
+});
+Object.defineProperty(exports, 'getTraceContext', {
+  enumerable: true,
+  get: function () {
+    return getTraceContext;
+  }
+});
+Object.defineProperty(exports, 'runWithLogLevel', {
+  enumerable: true,
+  get: function () {
+    return runWithLogLevel;
+  }
+});
+//# sourceMappingURL=logger.cjs.map

package/dist/logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.cjs","names":[],"sources":["../src/logger.ts"],"sourcesContent":["/**\n * Logger types and utilities for autotel\n *\n * **Zero-Config Option:** Don't provide a logger to `init()` and autotel uses\n * a built-in structured JSON logger with automatic trace context injection.\n *\n * **BYOL (Bring Your Own Logger):** Pass Pino or Bunyan to `init()` for\n * automatic instrumentation with trace context and OTLP log export.\n *\n * ## Logger Signature\n *\n * Autotel v2.10+ uses **Pino's signature**: `logger.info({ metadata }, 'message')`.\n *\n * ### Backward Compatibility\n *\n * The built-in logger auto-detects legacy Winston-style calls and swaps arguments:\n * ```typescript\n * // Legacy (auto-detected and handled)\n * logger.info('User created', { userId: '123' });\n * // → Internally treated as: logger.info({ userId: '123' }, 'User created')\n * // → Logs warning in development, works silently in production\n * ```\n *\n * ### Recommended Usage\n *\n * ```typescript\n * // ✅ Pino-style (preferred)\n * logger.info({ userId: '123' }, 'User created');\n *\n * // ✅ Simple message (no metadata)\n * logger.info('Server started');\n * ```\n *\n * **Note:** If you BYOL (bring your own logger), it must use Pino signature.\n * Winston and other `(message, meta)` loggers are NOT compatible.\n * For Winston, use `@opentelemetry/instrumentation-winston` instead.\n *\n * @example Zero-config (uses built-in logger)\n * ```typescript\n * import { init } from 'autotel';\n *\n * init({ service: 'my-app' });\n * // Internal logs: {\"level\":\"info\",\"service\":\"my-app\",\"msg\":\"...\",\"traceId\":\"...\"}\n * ```\n *\n * @example Using built-in logger directly\n * ```typescript\n * import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';\n *\n * const log = createBuiltinLogger('my-service');\n *\n * // Simple message (no metadata)\n * log.info('Server started');\n *\n * // With metadata (Pino-style: object first, message second)\n * log.info({ userId: '123' }, 'User created');\n * // Output: {\"level\":\"info\",\"service\":\"my-service\",\"msg\":\"User created\",\"userId\":\"123\",\"traceId\":\"...\"}\n *\n * // Dynamic log level per-request\n * runWithLogLevel('debug', () => {\n *   log.debug('Debug info for this request only');\n * });\n * ```\n *\n * @example Using Pino (recommended for production, auto-instrumented)\n * ```typescript\n * import pino from 'pino';  // npm install pino\n * import { init } from 'autotel';\n *\n * const logger = pino({ level: 'info' });\n * init({ service: 'my-app', logger });\n *\n * // Logs automatically include traceId/spanId and export via OTLP!\n * logger.info({ userId: '123' }, 'User created');\n * ```\n *\n * @example Using Bunyan (auto-instrumented, same signature as Pino)\n * ```typescript\n * import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan\n * import { init } from 'autotel';\n * import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';\n *\n * const logger = bunyan.createLogger({ name: 'my-app' });\n * init({\n *   service: 'my-app',\n *   logger,\n *   instrumentations: [new BunyanInstrumentation()]\n * });\n * ```\n *\n * @example Custom logger (MUST use Pino-compatible signature)\n * ```typescript\n * // ⚠️ Your custom logger MUST accept (object, message?) signature\n * const logger = {\n *   info: (extra, msg) => console.log(msg || '', extra),\n *   warn: (extra, msg) => console.warn(msg || '', extra),\n *   error: (extra, msg) => console.error(msg || '', extra),\n *   debug: (extra, msg) => console.debug(msg || '', extra),\n * };\n * init({ service: 'my-app', logger });\n * ```\n *\n * @example BYOL helper: inject trace context into any logger\n * ```typescript\n * import bunyan from 'bunyan';\n * import { getTraceContext } from 'autotel/logger';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n * const ctx = getTraceContext();\n * bunyanLogger.info({ ...ctx, userId: '123' }, 'Creating user');\n * ```\n */\n\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { getConfig } from './config';\n\n// ============================================================================\n// Logger Types\n// ============================================================================\n\n/**\n * Log level constants\n */\nexport const LOG_LEVEL = {\n  DEBUG: 'debug',\n  INFO: 'info',\n  WARN: 'warn',\n  ERROR: 'error',\n} as const;\n\nexport type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];\n\n/**\n * Logger configuration (for reference - not needed with BYOL approach)\n */\nexport interface LoggerConfig {\n  service: string;\n  level?: LogLevel;\n  pretty?: boolean;\n  redact?: string[] | false;\n}\n\n/**\n * Pino-compatible log function signature\n *\n * Matches Pino's actual LogFn type which supports:\n * - `(msg: string)` - simple string message\n * - `(obj: object, msg?: string)` - object first with optional message\n *\n * @example\n * ```typescript\n * logger.info('User logged in');\n * logger.info({ userId: '123' }, 'User created');\n * logger.error({ err: error }, 'Operation failed');\n * ```\n */\nexport interface LogFn {\n  (msg: string): void;\n  (obj: Record<string, unknown>, msg?: string): void;\n}\n\n/**\n * Simple logger interface - Pino/Bunyan-compatible\n *\n * Uses Pino's LogFn signature which supports both:\n * - `logger.info('message')` - simple string message\n * - `logger.info({ extra }, 'message')` - object first with optional message\n *\n * This is compatible with Pino, Bunyan, and any logger following this pattern.\n *\n * @example Using Pino (just works!)\n * ```typescript\n * import pino from 'pino';\n * const logger = pino({ level: 'info' });\n * init({ service: 'my-app', logger });\n * ```\n *\n * @example Direct usage\n * ```typescript\n * logger.info('Simple message');\n * logger.info({ userId: '123' }, 'User created');\n * logger.error({ err: error }, 'Operation failed');\n * ```\n */\nexport interface Logger {\n  info: LogFn;\n  warn: LogFn;\n  error: LogFn;\n  debug: LogFn;\n}\n\n/**\n * Alias for Logger interface (backwards compatibility)\n * @deprecated Use Logger instead\n */\nexport type ILogger = Logger;\n\n/**\n * Pino logger type - re-exported for convenience\n *\n * Note: This is a type-only export. To use Pino, install it as a peer dependency:\n * `npm install pino`\n */\nexport type { Logger as PinoLogger } from 'pino';\n\n// ============================================================================\n// LoggedOperation Decorator\n// ============================================================================\n\nexport interface LoggedOperationOptions {\n  /** Operation name for tracing (e.g., 'user.createUser') */\n  operationName: string;\n}\n\n/**\n * TS5+ Standard Decorator for logging and tracing operations\n * Uses TC39 Stage 3 decorator syntax\n *\n * This is the traditional per-method decorator approach.\n * For zero-boilerplate solution, see @Instrumented class decorator.\n *\n * @example\n * // Simple usage (Pino-style: object first, message second)\n * class OrderService {\n *   constructor(private readonly deps: { log: Logger }) {}\n *\n *   @LoggedOperation('order.create')\n *   async createOrder(data: CreateOrderData) {\n *     // ✅ Correct Pino-style logging\n *     this.deps.log.info({ orderId: data.id }, 'Creating order');\n *   }\n * }\n *\n * // Advanced usage (future-proof for options)\n * @LoggedOperation({ operationName: 'order.create' })\n * async createOrder(data: CreateOrderData) { }\n */\nexport function LoggedOperation(\n  operationNameOrOptions: string | LoggedOperationOptions,\n) {\n  const operationName =\n    typeof operationNameOrOptions === 'string'\n      ? operationNameOrOptions\n      : operationNameOrOptions.operationName;\n\n  return function <This, Args extends unknown[], Return>(\n    originalMethod: (this: This, ...args: Args) => Promise<Return>,\n    context: ClassMethodDecoratorContext<\n      This,\n      (this: This, ...args: Args) => Promise<Return>\n    >,\n  ) {\n    const methodName = String(context.name);\n\n    return async function (this: This, ...args: Args): Promise<Return> {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const log = (this as any).deps?.log;\n      const startTime = performance.now();\n\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(operationName, async (span) => {\n        try {\n          log?.info(\n            {\n              operation: operationName,\n              method: methodName,\n              args,\n            },\n            'Operation started',\n          );\n\n          const result = await originalMethod.apply(this, args);\n\n          const duration = performance.now() - startTime;\n          log?.info(\n            {\n              operation: operationName,\n              method: methodName,\n              duration,\n            },\n            'Operation completed',\n          );\n\n          span.setStatus({ code: SpanStatusCode.OK });\n          span.setAttributes({\n            'operation.name': operationName,\n            'operation.method': methodName,\n            'operation.duration': duration,\n            'operation.success': true,\n          });\n\n          return result;\n        } catch (error) {\n          const duration = performance.now() - startTime;\n          log?.error(\n            {\n              err: error instanceof Error ? error : undefined,\n              operation: operationName,\n              method: methodName,\n              duration,\n            },\n            'Operation failed',\n          );\n\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.setAttributes({\n            'operation.name': operationName,\n            'operation.method': methodName,\n            'operation.duration': duration,\n            'operation.success': false,\n            'error.type':\n              error instanceof Error ? error.constructor.name : 'Unknown',\n          });\n\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    };\n  };\n}\n\n// ============================================================================\n// Built-in Logger (re-exports)\n// ============================================================================\n\nexport {\n  autotelLogger,\n  createBuiltinLogger,\n  runWithLogLevel,\n  getTraceContext,\n  getActiveLogLevel,\n  type BuiltinLogLevel,\n  type BuiltinLoggerOptions,\n} from './autotel-logger';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA,MAAa,YAAY;CACvB,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;AA6GA,SAAgB,gBACd,wBACA;CACA,MAAM,gBACJ,OAAO,2BAA2B,WAC9B,yBACA,uBAAuB;CAE7B,OAAO,SACL,gBACA,SAIA;EACA,MAAM,aAAa,OAAO,QAAQ,IAAI;EAEtC,OAAO,eAA4B,GAAG,MAA6B;GAEjE,MAAM,MAAO,KAAa,MAAM;GAChC,MAAM,YAAY,YAAY,IAAI;GAKlC,OAHe,UACK,CAAC,CAAC,OAER,gBAAgB,eAAe,OAAO,SAAS;IAC3D,IAAI;KACF,KAAK,KACH;MACE,WAAW;MACX,QAAQ;MACR;KACF,GACA,mBACF;KAEA,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;KAEpD,MAAM,WAAW,YAAY,IAAI,IAAI;KACrC,KAAK,KACH;MACE,WAAW;MACX,QAAQ;MACR;KACF,GACA,qBACF;KAEA,KAAK,UAAU,EAAE,MAAM,eAAe,GAAG,CAAC;KAC1C,KAAK,cAAc;MACjB,kBAAkB;MAClB,oBAAoB;MACpB,sBAAsB;MACtB,qBAAqB;KACvB,CAAC;KAED,OAAO;IACT,SAAS,OAAO;KACd,MAAM,WAAW,YAAY,IAAI,IAAI;KACrC,KAAK,MACH;MACE,KAAK,iBAAiB,QAAQ,QAAQ;MACtC,WAAW;MACX,QAAQ;MACR;KACF,GACA,kBACF;KAEA,KAAK,UAAU;MACb,MAAM,eAAe;MACrB,SAAS,iBAAiB,QAAQ,MAAM,UAAU;KACpD,CAAC;KACD,KAAK,cAAc;MACjB,kBAAkB;MAClB,oBAAoB;MACpB,sBAAsB;MACtB,qBAAqB;MACrB,cACE,iBAAiB,QAAQ,MAAM,YAAY,OAAO;KACtD,CAAC;KAED,MAAM;IACR,UAAU;KACR,KAAK,IAAI;IACX;GACF,CAAC;EACH;CACF;AACF"}

package/dist/messaging.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_sampling = require('./sampling.cjs');
-const require_functional = require('./functional-zpzNLhky.cjs');
+const require_functional = require('./functional-C8B0Qa7o.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 

package/dist/messaging.js

@@ -1,5 +1,5 @@
 import { createLinkFromHeaders, extractLinksFromBatch } from "./sampling.js";
-import { a as trace$1 } from "./functional-DtI0u4vx.js";
+import { a as trace$1 } from "./functional-r-AUIRy_.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { SpanKind, context, propagation } from "@opentelemetry/api";
 

package/dist/{node-require-DF5QBX6z.cjs → node-require-CZ_PU448.cjs}

@@ -1,4 +1,6 @@
+const require_chunk = require('./chunk-C_NdSu1c.cjs');
 let node_module = require("node:module");
+node_module = require_chunk.__toESM(node_module, 1);
 
 //#region src/node-require.ts
 /**
@@ -16,7 +18,7 @@ function getNodeRequire() {
 	if (cachedRequire) return cachedRequire;
 	const base = typeof __filename === "string" ? __filename : require("url").pathToFileURL(__filename).href;
 	if (!base) throw Object.assign(/* @__PURE__ */ new Error("node require() is unavailable in this runtime"), { code: "MODULE_NOT_FOUND" });
-	cachedRequire = (0, node_module.createRequire)(base);
+	cachedRequire = node_module.createRequire(base);
 	return cachedRequire;
 }
 /**
@@ -75,8 +77,8 @@ function requireModule(id) {
 * forwarded. The live, mutable members of a real `require` — `.cache`,
 * `.main`, `.extensions` — are intentionally NOT exposed: a lazy wrapper
 * can't mirror that shared state without resolving eagerly, which would
-* reintroduce the workerd crash. Use `createRequire` directly if you need
-* them.
+* reintroduce the workerd crash. Use `nodeModule.createRequire` directly if
+* you need them.
 */
 const nodeRequire = ((id) => getNodeRequire()(id));
 const lazyResolve = ((id, options) => getNodeRequire().resolve(id, options));
@@ -96,4 +98,4 @@ Object.defineProperty(exports, 'safeRequire', {
     return safeRequire;
   }
 });
-//# sourceMappingURL=node-require-DF5QBX6z.cjs.map
+//# sourceMappingURL=node-require-CZ_PU448.cjs.map

package/dist/node-require-CZ_PU448.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-require-CZ_PU448.cjs","names":["nodeModule"],"sources":["../src/node-require.ts"],"sourcesContent":["/**\n * Cross-format require() helper for CJS and ESM compatibility\n *\n * Provides a synchronous `require()` function that works in both:\n * - CJS builds: Uses native `require`\n * - ESM builds: Uses `createRequire(import.meta.url)`\n *\n * This allows optional peer dependencies and dynamic module loading\n * to work synchronously in both module formats.\n */\n\n// Namespace import, not `import { createRequire }`. A static *named* import of a\n// Node builtin breaks browser bundlers: tools like Vite rewrite `node:module`\n// to a stub (`__vite-browser-external`) that exports nothing, and Rollup hard-\n// errors on the unresolved named binding (\"createRequire is not exported by\n// __vite-browser-external\") — failing the consumer's build even though this\n// code never runs in the browser. A namespace import has no named binding to\n// resolve, so it bundles cleanly; `.createRequire` is read lazily below and is\n// only ever touched in a real Node runtime.\nimport * as nodeModule from 'node:module';\n\n// `__filename` is provided by CJS and by esbuild's CJS output wrapper, but\n// is undefined under pure ESM. `import.meta.url` is provided by ESM. Pick\n// whichever is available so the helper works in:\n//   - native CJS (autotel's published `.cjs`)\n//   - native ESM (autotel's published `.js`)\n//   - ESM-bundled-into-CJS by a downstream consumer (e.g. CDK's\n//     `aws-lambda-nodejs` → esbuild with `format: cjs`). esbuild rewrites\n//     `import.meta` to `{}` in this case, so `createRequire(import.meta.url)`\n//     alone collapses to `createRequire(undefined)` and crashes at load.\n// `typeof __filename` does NOT throw when the identifier is undeclared, so\n// the ESM build evaluates the conditional safely.\ndeclare const __filename: string | undefined;\n\n// Build the Node `require` lazily on first use. Calling `createRequire`\n// eagerly at module load crashes in runtimes where neither `__filename` nor\n// `import.meta.url` resolves to a path — e.g. Cloudflare Workers / workerd,\n// where the bundle has no module path and `createRequire(undefined)` throws\n// synchronously at import. Deferring the call keeps merely importing this\n// module (and therefore anything that re-exports it, such as `track`)\n// side-effect-free; Node/CJS/ESM still get a real `require` on first call.\nlet cachedRequire: NodeRequire | undefined;\n\nfunction getNodeRequire(): NodeRequire {\n  if (cachedRequire) return cachedRequire;\n  const base = typeof __filename === 'string' ? __filename : import.meta.url;\n  if (!base) {\n    // No module path in this runtime. Surface as a missing-module error so\n    // optional lookups via `safeRequire()` degrade gracefully to `undefined`.\n    throw Object.assign(\n      new Error('node require() is unavailable in this runtime'),\n      { code: 'MODULE_NOT_FOUND' },\n    );\n  }\n  cachedRequire = nodeModule.createRequire(base);\n  return cachedRequire;\n}\n\n/**\n * Synchronously require a module (works in both CJS and ESM)\n *\n * @param id - Module ID to require\n * @returns The required module\n * @throws Error if module cannot be loaded\n *\n * @example\n * ```typescript\n * import { safeRequire } from './node-require';\n *\n * const traceloop = safeRequire('@traceloop/node-server-sdk');\n * if (traceloop) {\n *   traceloop.initialize({ ... });\n * }\n * ```\n */\nexport function safeRequire<T = unknown>(id: string): T | undefined {\n  try {\n    return getNodeRequire()(id) as T;\n  } catch (error) {\n    if (error && (error as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND') {\n      // Optional dependency missing – return undefined\n      return undefined;\n    }\n    // Any other error is a real bug: rethrow\n    throw error;\n  }\n}\n\n/**\n * Synchronously require a module (throws if not found)\n *\n * Use this when the module is required (not optional).\n *\n * @param id - Module ID to require\n * @returns The required module\n * @throws Error if module cannot be loaded\n *\n * @example\n * ```typescript\n * import { requireModule } from './node-require';\n *\n * const fs = requireModule<typeof import('node:fs')>('node:fs');\n * const content = fs.readFileSync('file.txt', 'utf8');\n * ```\n */\nexport function requireModule<T = unknown>(id: string): T {\n  return getNodeRequire()(id) as T;\n}\n\n/**\n * Direct access to the nodeRequire function (for advanced use cases).\n *\n * Lazily resolves the underlying Node `require` on first call, so importing\n * this binding never triggers `createRequire` in runtimes that lack a module\n * path (e.g. Cloudflare Workers).\n *\n * Only the call signature and `resolve` (including `resolve.paths`) are\n * forwarded. The live, mutable members of a real `require` — `.cache`,\n * `.main`, `.extensions` — are intentionally NOT exposed: a lazy wrapper\n * can't mirror that shared state without resolving eagerly, which would\n * reintroduce the workerd crash. Use `nodeModule.createRequire` directly if\n * you need them.\n */\nconst nodeRequire = ((id: string) => getNodeRequire()(id)) as NodeRequire;\nconst lazyResolve = ((id: string, options?: { paths?: string[] }) =>\n  getNodeRequire().resolve(id, options)) as NodeRequire['resolve'];\nlazyResolve.paths = (request: string) =>\n  getNodeRequire().resolve.paths(request);\nnodeRequire.resolve = lazyResolve;\n\nexport { nodeRequire };\n"],"mappings":";;;;;;;;;;;;;;;AAyCA,IAAI;AAEJ,SAAS,iBAA8B;CACrC,IAAI,eAAe,OAAO;CAC1B,MAAM,OAAO,OAAO,eAAe,WAAW;CAC9C,IAAI,CAAC,MAGH,MAAM,OAAO,uBACX,IAAI,MAAM,+CAA+C,GACzD,EAAE,MAAM,mBAAmB,CAC7B;CAEF,gBAAgBA,YAAW,cAAc,IAAI;CAC7C,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,YAAyB,IAA2B;CAClE,IAAI;EACF,OAAO,eAAe,CAAC,CAAC,EAAE;CAC5B,SAAS,OAAO;EACd,IAAI,SAAU,MAAgC,SAAS,oBAErD;EAGF,MAAM;CACR;AACF;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,cAA2B,IAAe;CACxD,OAAO,eAAe,CAAC,CAAC,EAAE;AAC5B;;;;;;;;;;;;;;;AAgBA,MAAM,gBAAgB,OAAe,eAAe,CAAC,CAAC,EAAE;AACxD,MAAM,gBAAgB,IAAY,YAChC,eAAe,CAAC,CAAC,QAAQ,IAAI,OAAO;AACtC,YAAY,SAAS,YACnB,eAAe,CAAC,CAAC,QAAQ,MAAM,OAAO;AACxC,YAAY,UAAU"}

package/dist/{node-require-Db1oDpLj.js → node-require-vROmTeJ8.js}

@@ -1,4 +1,4 @@
-import { createRequire } from "node:module";
+import * as nodeModule from "node:module";
 
 //#region src/node-require.ts
 /**
@@ -16,7 +16,7 @@ function getNodeRequire() {
 	if (cachedRequire) return cachedRequire;
 	const base = typeof __filename === "string" ? __filename : import.meta.url;
 	if (!base) throw Object.assign(/* @__PURE__ */ new Error("node require() is unavailable in this runtime"), { code: "MODULE_NOT_FOUND" });
-	cachedRequire = createRequire(base);
+	cachedRequire = nodeModule.createRequire(base);
 	return cachedRequire;
 }
 /**
@@ -75,8 +75,8 @@ function requireModule(id) {
 * forwarded. The live, mutable members of a real `require` — `.cache`,
 * `.main`, `.extensions` — are intentionally NOT exposed: a lazy wrapper
 * can't mirror that shared state without resolving eagerly, which would
-* reintroduce the workerd crash. Use `createRequire` directly if you need
-* them.
+* reintroduce the workerd crash. Use `nodeModule.createRequire` directly if
+* you need them.
 */
 const nodeRequire = ((id) => getNodeRequire()(id));
 const lazyResolve = ((id, options) => getNodeRequire().resolve(id, options));
@@ -85,4 +85,4 @@ nodeRequire.resolve = lazyResolve;
 
 //#endregion
 export { safeRequire as n, requireModule as t };
-//# sourceMappingURL=node-require-Db1oDpLj.js.map
+//# sourceMappingURL=node-require-vROmTeJ8.js.map

package/dist/node-require-vROmTeJ8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-require-vROmTeJ8.js","names":[],"sources":["../src/node-require.ts"],"sourcesContent":["/**\n * Cross-format require() helper for CJS and ESM compatibility\n *\n * Provides a synchronous `require()` function that works in both:\n * - CJS builds: Uses native `require`\n * - ESM builds: Uses `createRequire(import.meta.url)`\n *\n * This allows optional peer dependencies and dynamic module loading\n * to work synchronously in both module formats.\n */\n\n// Namespace import, not `import { createRequire }`. A static *named* import of a\n// Node builtin breaks browser bundlers: tools like Vite rewrite `node:module`\n// to a stub (`__vite-browser-external`) that exports nothing, and Rollup hard-\n// errors on the unresolved named binding (\"createRequire is not exported by\n// __vite-browser-external\") — failing the consumer's build even though this\n// code never runs in the browser. A namespace import has no named binding to\n// resolve, so it bundles cleanly; `.createRequire` is read lazily below and is\n// only ever touched in a real Node runtime.\nimport * as nodeModule from 'node:module';\n\n// `__filename` is provided by CJS and by esbuild's CJS output wrapper, but\n// is undefined under pure ESM. `import.meta.url` is provided by ESM. Pick\n// whichever is available so the helper works in:\n//   - native CJS (autotel's published `.cjs`)\n//   - native ESM (autotel's published `.js`)\n//   - ESM-bundled-into-CJS by a downstream consumer (e.g. CDK's\n//     `aws-lambda-nodejs` → esbuild with `format: cjs`). esbuild rewrites\n//     `import.meta` to `{}` in this case, so `createRequire(import.meta.url)`\n//     alone collapses to `createRequire(undefined)` and crashes at load.\n// `typeof __filename` does NOT throw when the identifier is undeclared, so\n// the ESM build evaluates the conditional safely.\ndeclare const __filename: string | undefined;\n\n// Build the Node `require` lazily on first use. Calling `createRequire`\n// eagerly at module load crashes in runtimes where neither `__filename` nor\n// `import.meta.url` resolves to a path — e.g. Cloudflare Workers / workerd,\n// where the bundle has no module path and `createRequire(undefined)` throws\n// synchronously at import. Deferring the call keeps merely importing this\n// module (and therefore anything that re-exports it, such as `track`)\n// side-effect-free; Node/CJS/ESM still get a real `require` on first call.\nlet cachedRequire: NodeRequire | undefined;\n\nfunction getNodeRequire(): NodeRequire {\n  if (cachedRequire) return cachedRequire;\n  const base = typeof __filename === 'string' ? __filename : import.meta.url;\n  if (!base) {\n    // No module path in this runtime. Surface as a missing-module error so\n    // optional lookups via `safeRequire()` degrade gracefully to `undefined`.\n    throw Object.assign(\n      new Error('node require() is unavailable in this runtime'),\n      { code: 'MODULE_NOT_FOUND' },\n    );\n  }\n  cachedRequire = nodeModule.createRequire(base);\n  return cachedRequire;\n}\n\n/**\n * Synchronously require a module (works in both CJS and ESM)\n *\n * @param id - Module ID to require\n * @returns The required module\n * @throws Error if module cannot be loaded\n *\n * @example\n * ```typescript\n * import { safeRequire } from './node-require';\n *\n * const traceloop = safeRequire('@traceloop/node-server-sdk');\n * if (traceloop) {\n *   traceloop.initialize({ ... });\n * }\n * ```\n */\nexport function safeRequire<T = unknown>(id: string): T | undefined {\n  try {\n    return getNodeRequire()(id) as T;\n  } catch (error) {\n    if (error && (error as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND') {\n      // Optional dependency missing – return undefined\n      return undefined;\n    }\n    // Any other error is a real bug: rethrow\n    throw error;\n  }\n}\n\n/**\n * Synchronously require a module (throws if not found)\n *\n * Use this when the module is required (not optional).\n *\n * @param id - Module ID to require\n * @returns The required module\n * @throws Error if module cannot be loaded\n *\n * @example\n * ```typescript\n * import { requireModule } from './node-require';\n *\n * const fs = requireModule<typeof import('node:fs')>('node:fs');\n * const content = fs.readFileSync('file.txt', 'utf8');\n * ```\n */\nexport function requireModule<T = unknown>(id: string): T {\n  return getNodeRequire()(id) as T;\n}\n\n/**\n * Direct access to the nodeRequire function (for advanced use cases).\n *\n * Lazily resolves the underlying Node `require` on first call, so importing\n * this binding never triggers `createRequire` in runtimes that lack a module\n * path (e.g. Cloudflare Workers).\n *\n * Only the call signature and `resolve` (including `resolve.paths`) are\n * forwarded. The live, mutable members of a real `require` — `.cache`,\n * `.main`, `.extensions` — are intentionally NOT exposed: a lazy wrapper\n * can't mirror that shared state without resolving eagerly, which would\n * reintroduce the workerd crash. Use `nodeModule.createRequire` directly if\n * you need them.\n */\nconst nodeRequire = ((id: string) => getNodeRequire()(id)) as NodeRequire;\nconst lazyResolve = ((id: string, options?: { paths?: string[] }) =>\n  getNodeRequire().resolve(id, options)) as NodeRequire['resolve'];\nlazyResolve.paths = (request: string) =>\n  getNodeRequire().resolve.paths(request);\nnodeRequire.resolve = lazyResolve;\n\nexport { nodeRequire };\n"],"mappings":";;;;;;;;;;;;;AAyCA,IAAI;AAEJ,SAAS,iBAA8B;CACrC,IAAI,eAAe,OAAO;CAC1B,MAAM,OAAO,OAAO,eAAe,WAAW,aAAa,OAAO,KAAK;CACvE,IAAI,CAAC,MAGH,MAAM,OAAO,uBACX,IAAI,MAAM,+CAA+C,GACzD,EAAE,MAAM,mBAAmB,CAC7B;CAEF,gBAAgB,WAAW,cAAc,IAAI;CAC7C,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,YAAyB,IAA2B;CAClE,IAAI;EACF,OAAO,eAAe,CAAC,CAAC,EAAE;CAC5B,SAAS,OAAO;EACd,IAAI,SAAU,MAAgC,SAAS,oBAErD;EAGF,MAAM;CACR;AACF;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,cAA2B,IAAe;CACxD,OAAO,eAAe,CAAC,CAAC,EAAE;AAC5B;;;;;;;;;;;;;;;AAgBA,MAAM,gBAAgB,OAAe,eAAe,CAAC,CAAC,EAAE;AACxD,MAAM,gBAAgB,IAAY,YAChC,eAAe,CAAC,CAAC,QAAQ,IAAI,OAAO;AACtC,YAAY,SAAS,YACnB,eAAe,CAAC,CAAC,QAAQ,MAAM,OAAO;AACxC,YAAY,UAAU"}

package/dist/{operation-context-C-2hmmtP.js → operation-context-CKBoA4Qy.js}

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import * as nodeAsyncHooks from "node:async_hooks";
 
 //#region src/operation-context.ts
 /**
@@ -13,7 +13,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 /**
 * AsyncLocalStorage instance for tracking operation context
 */
-const operationStorage = new AsyncLocalStorage();
+const operationStorage = new nodeAsyncHooks.AsyncLocalStorage();
 /**
 * Get the current operation context (if any)
 *
@@ -56,4 +56,4 @@ function runInOperationContext(name, fn) {
 
 //#endregion
 export { runInOperationContext as n, getOperationContext as t };
-//# sourceMappingURL=operation-context-C-2hmmtP.js.map
+//# sourceMappingURL=operation-context-CKBoA4Qy.js.map

package/dist/operation-context-CKBoA4Qy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-context-CKBoA4Qy.js","names":[],"sources":["../src/operation-context.ts"],"sourcesContent":["/**\n * Operation context tracking using AsyncLocalStorage\n *\n * This module provides a way to track operation names across async boundaries\n * so they can be automatically captured in events events.\n *\n * We cannot read span attributes from OpenTelemetry's API (it's write-only),\n * so we maintain our own async context storage.\n */\n\n// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeAsyncHooks from 'node:async_hooks';\n\n/**\n * Operation context that flows through async operations\n */\nexport interface OperationContext {\n  /**\n   * The name of the current operation\n   * This is set by trace() or span() and can be read by events\n   */\n  name: string;\n}\n\n/**\n * AsyncLocalStorage instance for tracking operation context\n */\nconst operationStorage =\n  new nodeAsyncHooks.AsyncLocalStorage<OperationContext>();\n\n/**\n * Get the current operation context (if any)\n *\n * @returns The current operation context, or undefined if not in an operation\n *\n * @example\n * ```typescript\n * const ctx = getOperationContext();\n * if (ctx) {\n *   console.log('Current operation:', ctx.name);\n * }\n * ```\n */\nexport function getOperationContext(): OperationContext | undefined {\n  return operationStorage.getStore();\n}\n\n/**\n * Run a function within an operation context\n *\n * This sets the operation name for the duration of the function execution,\n * including all async operations spawned from it.\n *\n * @param name - The operation name to set\n * @param fn - The function to execute within the context\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * const result = await runInOperationContext('user.create', async () => {\n *   // Any events.trackEvent() calls here will automatically capture\n *   // 'operation.name': 'user.create'\n *   await createUser();\n *   return 'success';\n * });\n * ```\n */\nexport function runInOperationContext<T>(name: string, fn: () => T): T {\n  return operationStorage.run({ name }, fn);\n}\n\n/**\n * Update the operation name in the current context\n *\n * This is useful when you want to change the operation name within\n * an already-established context (e.g., when entering a nested span).\n *\n * @param name - The new operation name\n *\n * @example\n * ```typescript\n * runInOperationContext('parent.operation', () => {\n *   // operation.name is 'parent.operation'\n *\n *   updateOperationName('nested.operation');\n *   // operation.name is now 'nested.operation'\n * });\n * ```\n */\nexport function updateOperationName(name: string): void {\n  const store = operationStorage.getStore();\n  if (store) {\n    store.name = name;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA2BA,MAAM,mBACJ,IAAI,eAAe,kBAAoC;;;;;;;;;;;;;;AAezD,SAAgB,sBAAoD;CAClE,OAAO,iBAAiB,SAAS;AACnC;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,sBAAyB,MAAc,IAAgB;CACrE,OAAO,iBAAiB,IAAI,EAAE,KAAK,GAAG,EAAE;AAC1C"}

package/dist/{operation-context-n4_obUwq.cjs → operation-context-D6LDf4W_.cjs}

@@ -1,4 +1,6 @@
+const require_chunk = require('./chunk-C_NdSu1c.cjs');
 let node_async_hooks = require("node:async_hooks");
+node_async_hooks = require_chunk.__toESM(node_async_hooks, 1);
 
 //#region src/operation-context.ts
 /**
@@ -67,4 +69,4 @@ Object.defineProperty(exports, 'runInOperationContext', {
     return runInOperationContext;
   }
 });
-//# sourceMappingURL=operation-context-n4_obUwq.cjs.map
+//# sourceMappingURL=operation-context-D6LDf4W_.cjs.map

package/dist/operation-context-D6LDf4W_.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-context-D6LDf4W_.cjs","names":["nodeAsyncHooks"],"sources":["../src/operation-context.ts"],"sourcesContent":["/**\n * Operation context tracking using AsyncLocalStorage\n *\n * This module provides a way to track operation names across async boundaries\n * so they can be automatically captured in events events.\n *\n * We cannot read span attributes from OpenTelemetry's API (it's write-only),\n * so we maintain our own async context storage.\n */\n\n// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeAsyncHooks from 'node:async_hooks';\n\n/**\n * Operation context that flows through async operations\n */\nexport interface OperationContext {\n  /**\n   * The name of the current operation\n   * This is set by trace() or span() and can be read by events\n   */\n  name: string;\n}\n\n/**\n * AsyncLocalStorage instance for tracking operation context\n */\nconst operationStorage =\n  new nodeAsyncHooks.AsyncLocalStorage<OperationContext>();\n\n/**\n * Get the current operation context (if any)\n *\n * @returns The current operation context, or undefined if not in an operation\n *\n * @example\n * ```typescript\n * const ctx = getOperationContext();\n * if (ctx) {\n *   console.log('Current operation:', ctx.name);\n * }\n * ```\n */\nexport function getOperationContext(): OperationContext | undefined {\n  return operationStorage.getStore();\n}\n\n/**\n * Run a function within an operation context\n *\n * This sets the operation name for the duration of the function execution,\n * including all async operations spawned from it.\n *\n * @param name - The operation name to set\n * @param fn - The function to execute within the context\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * const result = await runInOperationContext('user.create', async () => {\n *   // Any events.trackEvent() calls here will automatically capture\n *   // 'operation.name': 'user.create'\n *   await createUser();\n *   return 'success';\n * });\n * ```\n */\nexport function runInOperationContext<T>(name: string, fn: () => T): T {\n  return operationStorage.run({ name }, fn);\n}\n\n/**\n * Update the operation name in the current context\n *\n * This is useful when you want to change the operation name within\n * an already-established context (e.g., when entering a nested span).\n *\n * @param name - The new operation name\n *\n * @example\n * ```typescript\n * runInOperationContext('parent.operation', () => {\n *   // operation.name is 'parent.operation'\n *\n *   updateOperationName('nested.operation');\n *   // operation.name is now 'nested.operation'\n * });\n * ```\n */\nexport function updateOperationName(name: string): void {\n  const store = operationStorage.getStore();\n  if (store) {\n    store.name = name;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA2BA,MAAM,mBACJ,IAAIA,iBAAe,kBAAoC;;;;;;;;;;;;;;AAezD,SAAgB,sBAAoD;CAClE,OAAO,iBAAiB,SAAS;AACnC;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,sBAAyB,MAAc,IAAgB;CACrE,OAAO,iBAAiB,IAAI,EAAE,KAAK,GAAG,EAAE;AAC1C"}

package/dist/register.cjs

@@ -1,4 +1,6 @@
+const require_chunk = require('./chunk-C_NdSu1c.cjs');
 let node_module = require("node:module");
+node_module = require_chunk.__toESM(node_module, 1);
 
 //#region src/register.ts
 /**
@@ -32,7 +34,7 @@ let node_module = require("node:module");
 * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md
 * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options
 */
-(0, node_module.register)("@opentelemetry/instrumentation/hook.mjs", require("url").pathToFileURL(__filename).href);
+node_module.register("@opentelemetry/instrumentation/hook.mjs", require("url").pathToFileURL(__filename).href);
 
 //#endregion
 //# sourceMappingURL=register.cjs.map

package/dist/register.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"register.cjs","names":[],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAoCS,wFAA0D"}
+{"version":3,"file":"register.cjs","names":["nodeModule"],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\n// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeModule from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nnodeModule.register('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCAA,YAAW,SAAS,wFAA0D"}

package/dist/register.js

@@ -1,4 +1,4 @@
-import { register } from "node:module";
+import * as nodeModule from "node:module";
 
 //#region src/register.ts
 /**
@@ -32,7 +32,7 @@ import { register } from "node:module";
 * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md
 * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options
 */
-register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
+nodeModule.register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
 
 //#endregion
 export {  };

package/dist/register.js.map

@@ -1 +1 @@
-{"version":3,"file":"register.js","names":[],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAS,2CAA2C,OAAO,KAAK,GAAG"}
+{"version":3,"file":"register.js","names":[],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\n// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeModule from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nnodeModule.register('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,WAAW,SAAS,2CAA2C,OAAO,KAAK,GAAG"}

package/dist/semantic-helpers.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_functional = require('./functional-zpzNLhky.cjs');
+const require_functional = require('./functional-C8B0Qa7o.cjs');
 
 //#region src/semantic-helpers.ts
 /**

package/dist/semantic-helpers.js

@@ -1,4 +1,4 @@
-import { a as trace } from "./functional-DtI0u4vx.js";
+import { a as trace } from "./functional-r-AUIRy_.js";
 
 //#region src/semantic-helpers.ts
 /**

package/dist/{stable-hash-Cg5cT34Q.js → stable-hash-ChFBIhNt.js}

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import * as nodeCrypto from "node:crypto";
 
 //#region src/stable-hash.ts
 /**
@@ -15,9 +15,9 @@ function stableStringify(value) {
 }
 /** Stable sha256 of any JSON-serializable value. */
 function hashJson(value) {
-	return createHash("sha256").update(stableStringify(value)).digest("hex");
+	return nodeCrypto.createHash("sha256").update(stableStringify(value)).digest("hex");
 }
 
 //#endregion
 export { hashJson as t };
-//# sourceMappingURL=stable-hash-Cg5cT34Q.js.map
+//# sourceMappingURL=stable-hash-ChFBIhNt.js.map

package/dist/stable-hash-ChFBIhNt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable-hash-ChFBIhNt.js","names":[],"sources":["../src/stable-hash.ts"],"sourcesContent":["// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeCrypto from 'node:crypto';\n\n/**\n * Deterministic JSON stringify with sorted object keys, so two structurally\n * equal values always produce the same string regardless of key insertion\n * order. Shared by `defineEvent` and the validation layer for stable schema\n * hashes.\n */\nexport function stableStringify(value: unknown): string {\n  if (value === null || value === undefined || typeof value !== 'object') {\n    return JSON.stringify(value);\n  }\n  if (Array.isArray(value)) {\n    return '[' + value.map((v) => stableStringify(v)).join(',') + ']';\n  }\n  const obj = value as Record<string, unknown>;\n  const body = Object.keys(obj)\n    .toSorted()\n    .map((k) => JSON.stringify(k) + ':' + stableStringify(obj[k]))\n    .join(',');\n  return '{' + body + '}';\n}\n\n/** Stable sha256 of any JSON-serializable value. */\nexport function hashJson(value: unknown): string {\n  return nodeCrypto\n    .createHash('sha256')\n    .update(stableStringify(value))\n    .digest('hex');\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,gBAAgB,OAAwB;CACtD,IAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,UAAU,UAC5D,OAAO,KAAK,UAAU,KAAK;CAE7B,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,KAAK,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI;CAEhE,MAAM,MAAM;CAKZ,OAAO,MAJM,OAAO,KAAK,GAAG,CAAC,CAC1B,SAAS,CAAC,CACV,KAAK,MAAM,KAAK,UAAU,CAAC,IAAI,MAAM,gBAAgB,IAAI,EAAE,CAAC,CAAC,CAC7D,KAAK,GACQ,IAAI;AACtB;;AAGA,SAAgB,SAAS,OAAwB;CAC/C,OAAO,WACJ,WAAW,QAAQ,CAAC,CACpB,OAAO,gBAAgB,KAAK,CAAC,CAAC,CAC9B,OAAO,KAAK;AACjB"}

package/dist/{stable-hash-BNTMrmdB.cjs → stable-hash-brKISGf1.cjs}

@@ -1,4 +1,6 @@
+const require_chunk = require('./chunk-C_NdSu1c.cjs');
 let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto, 1);
 
 //#region src/stable-hash.ts
 /**
@@ -15,7 +17,7 @@ function stableStringify(value) {
 }
 /** Stable sha256 of any JSON-serializable value. */
 function hashJson(value) {
-	return (0, node_crypto.createHash)("sha256").update(stableStringify(value)).digest("hex");
+	return node_crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
 }
 
 //#endregion
@@ -25,4 +27,4 @@ Object.defineProperty(exports, 'hashJson', {
     return hashJson;
   }
 });
-//# sourceMappingURL=stable-hash-BNTMrmdB.cjs.map
+//# sourceMappingURL=stable-hash-brKISGf1.cjs.map

package/dist/stable-hash-brKISGf1.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable-hash-brKISGf1.cjs","names":["nodeCrypto"],"sources":["../src/stable-hash.ts"],"sourcesContent":["// namespace import for browser-bundler compat — see node-require.ts\nimport * as nodeCrypto from 'node:crypto';\n\n/**\n * Deterministic JSON stringify with sorted object keys, so two structurally\n * equal values always produce the same string regardless of key insertion\n * order. Shared by `defineEvent` and the validation layer for stable schema\n * hashes.\n */\nexport function stableStringify(value: unknown): string {\n  if (value === null || value === undefined || typeof value !== 'object') {\n    return JSON.stringify(value);\n  }\n  if (Array.isArray(value)) {\n    return '[' + value.map((v) => stableStringify(v)).join(',') + ']';\n  }\n  const obj = value as Record<string, unknown>;\n  const body = Object.keys(obj)\n    .toSorted()\n    .map((k) => JSON.stringify(k) + ':' + stableStringify(obj[k]))\n    .join(',');\n  return '{' + body + '}';\n}\n\n/** Stable sha256 of any JSON-serializable value. */\nexport function hashJson(value: unknown): string {\n  return nodeCrypto\n    .createHash('sha256')\n    .update(stableStringify(value))\n    .digest('hex');\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,gBAAgB,OAAwB;CACtD,IAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,UAAU,UAC5D,OAAO,KAAK,UAAU,KAAK;CAE7B,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,KAAK,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI;CAEhE,MAAM,MAAM;CAKZ,OAAO,MAJM,OAAO,KAAK,GAAG,CAAC,CAC1B,SAAS,CAAC,CACV,KAAK,MAAM,KAAK,UAAU,CAAC,IAAI,MAAM,gBAAgB,IAAI,EAAE,CAAC,CAAC,CAC7D,KAAK,GACQ,IAAI;AACtB;;AAGA,SAAgB,SAAS,OAAwB;CAC/C,OAAOA,YACJ,WAAW,QAAQ,CAAC,CACpB,OAAO,gBAAgB,KAAK,CAAC,CAAC,CAC9B,OAAO,KAAK;AACjB"}

package/dist/trace-context-Cijqoi6e.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-context-Cijqoi6e.d.cts","names":[],"sources":["../src/trace-context.ts"],"mappings":";;;;;;;UA2GiB,gBAAA;EACf,OAAA;EACA,MAAA;EACA,aAAA;AAAA;;;;;KAOU,gBAAA;;;;UAWK,WAAA;EAMW;EAJ1B,YAAA,CAAa,GAAA,UAAa,KAAA,EAAO,gBAAA;EAIvB;EAFV,aAAA,CAAc,KAAA,EAAO,MAAA,SAAe,gBAAA;EAItB;EAFd,SAAA,CAAU,MAAA;IAAU,IAAA,EAAM,cAAA;IAAgB,OAAA;EAAA;EAM1C;EAJA,OAAA,CAAQ,IAAA,EAAM,IAAA;EAMd;EAJA,QAAA,CAAS,KAAA,EAAO,IAAA;EAcJ;EAZZ,UAAA,CAAW,IAAA;EAmBL;EAjBN,WAAA;EAiB+C;;;;;;;AAET;AASxC;EAlBE,WAAA,CAAY,KAAA;EAkBiB;;;;;;EAX7B,KAAA,gBAAqB,MAAA,oBAA0B,MAAA,mBAC7C,KAAA,QAAa,MAAA,WACb,IAAA,GAAO,MAAA,OAAa,MAAA;AAAA;;;;;;UASP,cAAA,kBACE,MAAA;EAgEG;;;;;EAzDpB,UAAA,CAAW,GAAA;EAoBX;;;;;;;;;;;;;;;;;;EAAA,UAAA,CAAW,GAAA,UAAa,KAAA;EAmCnB;;;;;;;AAEkB;EA3BvB,aAAA,CAAc,GAAA;EA0DQ;;;;EApDtB,aAAA,IAAiB,GAAA,SAAY,YAAA;EAsDqB;;;;;;EA9ClD,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EAAU,SAAA,cAAuB,OAAA,CAAQ,CAAA;EA6CnC;;;;AAAqC;AAoO5D;EAxQE,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EACT,SAAA,sBACA,KAAA,EAAO,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BX,YAAA,kBACO,MAAA,6CACf,gBAAA,GAAmB,WAAA,GAAc,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6QhC;;;;;;;;;;;;iBAzCJ,mBAAA,WAA8B,MAAA,mBAC5C,SAAA;;;;;;aAQa,YAAA,CAAa,CAAA,MAAK,OAAA,CAAQ,CAAA;;;;;;;;;aAa1B,YAAA,CAAa,CAAA,GAAE,KAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;YAenC,UAAA,EACM,YAAA,CAAa,CAAA,IAAK,OAAA,CAAQ,CAAA,GAAE,SAAA,EAC7B,OAAA,CAAQ,CAAA,WAAY,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAG,OAAA,SAC9B,CAAA,GAAI,OAAA,CAAQ,CAAA,MAC3B,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA"}
+{"version":3,"file":"trace-context-Cijqoi6e.d.cts","names":[],"sources":["../src/trace-context.ts"],"mappings":";;;;;;;UA+GiB,gBAAA;EACf,OAAA;EACA,MAAA;EACA,aAAA;AAAA;;;;;KAOU,gBAAA;;;;UAWK,WAAA;EAMW;EAJ1B,YAAA,CAAa,GAAA,UAAa,KAAA,EAAO,gBAAA;EAIvB;EAFV,aAAA,CAAc,KAAA,EAAO,MAAA,SAAe,gBAAA;EAItB;EAFd,SAAA,CAAU,MAAA;IAAU,IAAA,EAAM,cAAA;IAAgB,OAAA;EAAA;EAM1C;EAJA,OAAA,CAAQ,IAAA,EAAM,IAAA;EAMd;EAJA,QAAA,CAAS,KAAA,EAAO,IAAA;EAcJ;EAZZ,UAAA,CAAW,IAAA;EAmBL;EAjBN,WAAA;EAiB+C;;;;;;;AAET;AASxC;EAlBE,WAAA,CAAY,KAAA;EAkBiB;;;;;;EAX7B,KAAA,gBAAqB,MAAA,oBAA0B,MAAA,mBAC7C,KAAA,QAAa,MAAA,WACb,IAAA,GAAO,MAAA,OAAa,MAAA;AAAA;;;;;;UASP,cAAA,kBACE,MAAA;EAgEG;;;;;EAzDpB,UAAA,CAAW,GAAA;EAoBX;;;;;;;;;;;;;;;;;;EAAA,UAAA,CAAW,GAAA,UAAa,KAAA;EAmCnB;;;;;;;AAEkB;EA3BvB,aAAA,CAAc,GAAA;EA0DQ;;;;EApDtB,aAAA,IAAiB,GAAA,SAAY,YAAA;EAsDqB;;;;;;EA9ClD,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EAAU,SAAA,cAAuB,OAAA,CAAQ,CAAA;EA6CnC;;;;AAAqC;AAoO5D;EAxQE,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EACT,SAAA,sBACA,KAAA,EAAO,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BX,YAAA,kBACO,MAAA,6CACf,gBAAA,GAAmB,WAAA,GAAc,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6QhC;;;;;;;;;;;;iBAzCJ,mBAAA,WAA8B,MAAA,mBAC5C,SAAA;;;;;;aAQa,YAAA,CAAa,CAAA,MAAK,OAAA,CAAQ,CAAA;;;;;;;;;aAa1B,YAAA,CAAa,CAAA,GAAE,KAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;YAenC,UAAA,EACM,YAAA,CAAa,CAAA,IAAK,OAAA,CAAQ,CAAA,GAAE,SAAA,EAC7B,OAAA,CAAQ,CAAA,WAAY,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAG,OAAA,SAC9B,CAAA,GAAI,OAAA,CAAQ,CAAA,MAC3B,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA"}

package/dist/trace-context-Cijqoi6e.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-context-Cijqoi6e.d.ts","names":[],"sources":["../src/trace-context.ts"],"mappings":";;;;;;;UA2GiB,gBAAA;EACf,OAAA;EACA,MAAA;EACA,aAAA;AAAA;;;;;KAOU,gBAAA;;;;UAWK,WAAA;EAMW;EAJ1B,YAAA,CAAa,GAAA,UAAa,KAAA,EAAO,gBAAA;EAIvB;EAFV,aAAA,CAAc,KAAA,EAAO,MAAA,SAAe,gBAAA;EAItB;EAFd,SAAA,CAAU,MAAA;IAAU,IAAA,EAAM,cAAA;IAAgB,OAAA;EAAA;EAM1C;EAJA,OAAA,CAAQ,IAAA,EAAM,IAAA;EAMd;EAJA,QAAA,CAAS,KAAA,EAAO,IAAA;EAcJ;EAZZ,UAAA,CAAW,IAAA;EAmBL;EAjBN,WAAA;EAiB+C;;;;;;;AAET;AASxC;EAlBE,WAAA,CAAY,KAAA;EAkBiB;;;;;;EAX7B,KAAA,gBAAqB,MAAA,oBAA0B,MAAA,mBAC7C,KAAA,QAAa,MAAA,WACb,IAAA,GAAO,MAAA,OAAa,MAAA;AAAA;;;;;;UASP,cAAA,kBACE,MAAA;EAgEG;;;;;EAzDpB,UAAA,CAAW,GAAA;EAoBX;;;;;;;;;;;;;;;;;;EAAA,UAAA,CAAW,GAAA,UAAa,KAAA;EAmCnB;;;;;;;AAEkB;EA3BvB,aAAA,CAAc,GAAA;EA0DQ;;;;EApDtB,aAAA,IAAiB,GAAA,SAAY,YAAA;EAsDqB;;;;;;EA9ClD,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EAAU,SAAA,cAAuB,OAAA,CAAQ,CAAA;EA6CnC;;;;AAAqC;AAoO5D;EAxQE,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EACT,SAAA,sBACA,KAAA,EAAO,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BX,YAAA,kBACO,MAAA,6CACf,gBAAA,GAAmB,WAAA,GAAc,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6QhC;;;;;;;;;;;;iBAzCJ,mBAAA,WAA8B,MAAA,mBAC5C,SAAA;;;;;;aAQa,YAAA,CAAa,CAAA,MAAK,OAAA,CAAQ,CAAA;;;;;;;;;aAa1B,YAAA,CAAa,CAAA,GAAE,KAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;YAenC,UAAA,EACM,YAAA,CAAa,CAAA,IAAK,OAAA,CAAQ,CAAA,GAAE,SAAA,EAC7B,OAAA,CAAQ,CAAA,WAAY,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAG,OAAA,SAC9B,CAAA,GAAI,OAAA,CAAQ,CAAA,MAC3B,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA"}
+{"version":3,"file":"trace-context-Cijqoi6e.d.ts","names":[],"sources":["../src/trace-context.ts"],"mappings":";;;;;;;UA+GiB,gBAAA;EACf,OAAA;EACA,MAAA;EACA,aAAA;AAAA;;;;;KAOU,gBAAA;;;;UAWK,WAAA;EAMW;EAJ1B,YAAA,CAAa,GAAA,UAAa,KAAA,EAAO,gBAAA;EAIvB;EAFV,aAAA,CAAc,KAAA,EAAO,MAAA,SAAe,gBAAA;EAItB;EAFd,SAAA,CAAU,MAAA;IAAU,IAAA,EAAM,cAAA;IAAgB,OAAA;EAAA;EAM1C;EAJA,OAAA,CAAQ,IAAA,EAAM,IAAA;EAMd;EAJA,QAAA,CAAS,KAAA,EAAO,IAAA;EAcJ;EAZZ,UAAA,CAAW,IAAA;EAmBL;EAjBN,WAAA;EAiB+C;;;;;;;AAET;AASxC;EAlBE,WAAA,CAAY,KAAA;EAkBiB;;;;;;EAX7B,KAAA,gBAAqB,MAAA,oBAA0B,MAAA,mBAC7C,KAAA,QAAa,MAAA,WACb,IAAA,GAAO,MAAA,OAAa,MAAA;AAAA;;;;;;UASP,cAAA,kBACE,MAAA;EAgEG;;;;;EAzDpB,UAAA,CAAW,GAAA;EAoBX;;;;;;;;;;;;;;;;;;EAAA,UAAA,CAAW,GAAA,UAAa,KAAA;EAmCnB;;;;;;;AAEkB;EA3BvB,aAAA,CAAc,GAAA;EA0DQ;;;;EApDtB,aAAA,IAAiB,GAAA,SAAY,YAAA;EAsDqB;;;;;;EA9ClD,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EAAU,SAAA,cAAuB,OAAA,CAAQ,CAAA;EA6CnC;;;;AAAqC;AAoO5D;EAxQE,eAAA,GAAkB,QAAA,SAAiB,MAAA,+BACpB,QAAA,EACT,SAAA,sBACA,KAAA,EAAO,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BX,YAAA,kBACO,MAAA,6CACf,gBAAA,GAAmB,WAAA,GAAc,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6QhC;;;;;;;;;;;;iBAzCJ,mBAAA,WAA8B,MAAA,mBAC5C,SAAA;;;;;;aAQa,YAAA,CAAa,CAAA,MAAK,OAAA,CAAQ,CAAA;;;;;;;;;aAa1B,YAAA,CAAa,CAAA,GAAE,KAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;YAenC,UAAA,EACM,YAAA,CAAa,CAAA,IAAK,OAAA,CAAQ,CAAA,GAAE,SAAA,EAC7B,OAAA,CAAQ,CAAA,WAAY,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAG,OAAA,SAC9B,CAAA,GAAI,OAAA,CAAQ,CAAA,MAC3B,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA"}

package/dist/trace-helpers.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_node_require = require('./node-require-DF5QBX6z.cjs');
+const require_node_require = require('./node-require-CZ_PU448.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/trace-helpers.ts

package/dist/trace-helpers.js

@@ -1,4 +1,4 @@
-import { t as requireModule } from "./node-require-Db1oDpLj.js";
+import { t as requireModule } from "./node-require-vROmTeJ8.js";
 import { SpanStatusCode, context, trace } from "@opentelemetry/api";
 
 //#region src/trace-helpers.ts