autotel 3.5.0 → 3.7.0

package/dist/decorators.cjs

@@ -1,71 +1,45 @@
-'use strict';
-
-require('./chunk-FGNDN2FD.cjs');
-require('./chunk-OPPXYVEZ.cjs');
-require('./chunk-VQTCQKHQ.cjs');
-var chunkZ7PW3KHL_cjs = require('./chunk-Z7PW3KHL.cjs');
-require('./chunk-R7QYGZUP.cjs');
-require('./chunk-QWW3E3JM.cjs');
-require('./chunk-CEAQK2QY.cjs');
-require('./chunk-ZNMBW67B.cjs');
-require('./chunk-IOYFAFHJ.cjs');
-require('./chunk-NEIB3TLD.cjs');
-require('./chunk-CU6IDACR.cjs');
-require('./chunk-6S5RUKU3.cjs');
-require('./chunk-NVAI5CCN.cjs');
-require('./chunk-VH77IPJN.cjs');
-require('./chunk-FU6R566Y.cjs');
-var chunkESLWRGAG_cjs = require('./chunk-ESLWRGAG.cjs');
-require('./chunk-YREV3LGG.cjs');
-var api = require('@opentelemetry/api');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_config = require('./config.cjs');
+const require_track = require('./track-3HY4NGV-.cjs');
+let _opentelemetry_api = require("@opentelemetry/api");
 
+//#region src/decorators.ts
 function Trace(nameOrOptions, maybeOptions) {
-  const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
-  return function(originalMethod, context) {
-    const methodName = String(context.name);
-    const methodStr = originalMethod?.toString() || "";
-    const isAsync = originalMethod && (originalMethod.constructor?.name === "AsyncFunction" || methodStr.trim().startsWith("async ") || methodStr.includes("[native code]") && methodStr.includes("async") || // Fallback: if function has async in its string representation
-    /async\s+/.test(methodStr));
-    if (!isAsync) {
-      return originalMethod;
-    }
-    const spanName = name || methodName;
-    return async function(...args) {
-      const config = chunkESLWRGAG_cjs.getConfig();
-      const tracer = config.tracer;
-      return tracer.startActiveSpan(spanName, async (span) => {
-        try {
-          const ctx = chunkZ7PW3KHL_cjs.createTraceContext(span);
-          const originalCtx = this.ctx;
-          try {
-            this.ctx = ctx;
-            const result = await originalMethod.apply(this, args);
-            span.setStatus({ code: api.SpanStatusCode.OK });
-            return result;
-          } finally {
-            if (originalCtx === void 0) {
-              delete this.ctx;
-            } else {
-              this.ctx = originalCtx;
-            }
-          }
-        } catch (error) {
-          span.setStatus({
-            code: api.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : "Unknown error"
-          });
-          span.recordException(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          throw error;
-        } finally {
-          span.end();
-        }
-      });
-    };
-  };
+	const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
+	return function(originalMethod, context) {
+		const methodName = String(context.name);
+		const methodStr = originalMethod?.toString() || "";
+		if (!(originalMethod && (originalMethod.constructor?.name === "AsyncFunction" || methodStr.trim().startsWith("async ") || methodStr.includes("[native code]") && methodStr.includes("async") || /async\s+/.test(methodStr)))) return originalMethod;
+		const spanName = name || methodName;
+		return async function(...args) {
+			return require_config.getConfig().tracer.startActiveSpan(spanName, async (span) => {
+				try {
+					const ctx = require_track.createTraceContext(span);
+					const originalCtx = this.ctx;
+					try {
+						this.ctx = ctx;
+						const result = await originalMethod.apply(this, args);
+						span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+						return result;
+					} finally {
+						if (originalCtx === void 0) delete this.ctx;
+						else this.ctx = originalCtx;
+					}
+				} catch (error) {
+					span.setStatus({
+						code: _opentelemetry_api.SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : "Unknown error"
+					});
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+	};
 }
 
+//#endregion
 exports.Trace = Trace;
-//# sourceMappingURL=decorators.cjs.map
 //# sourceMappingURL=decorators.cjs.map

package/dist/decorators.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/decorators.ts"],"names":["getConfig","createTraceContext","SpanStatusCode"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmGO,SAAS,KAAA,CACd,eACA,YAAA,EAIK;AAEL,EAAA,MAAM,IAAA,GACJ,OAAO,aAAA,KAAkB,QAAA,GAAW,gBAAgB,aAAA,EAAe,IAAA;AASrE,EAAA,OAAO,SACL,gBACA,OAAA,EACG;AACH,IAAA,MAAM,UAAA,GAAa,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA;AAKtC,IAAA,MAAM,SAAA,GAAY,cAAA,EAAgB,QAAA,EAAS,IAAK,EAAA;AAChD,IAAA,MAAM,UACJ,cAAA,KACC,cAAA,CAAe,aAAa,IAAA,KAAS,eAAA,IACpC,UAAU,IAAA,EAAK,CAAE,UAAA,CAAW,QAAQ,KACnC,SAAA,CAAU,QAAA,CAAS,eAAe,CAAA,IAAK,SAAA,CAAU,SAAS,OAAO,CAAA;AAAA,IAElE,UAAA,CAAW,KAAK,SAAS,CAAA,CAAA;AAE7B,IAAA,IAAI,CAAC,OAAA,EAAS;AAEZ,MAAA,OAAO,cAAA;AAAA,IACT;AAEA,IAAA,MAAM,WAAW,IAAA,IAAQ,UAAA;AAEzB,IAAA,OAAO,kBAEF,IAAA,EACe;AAClB,MAAA,MAAM,SAASA,2BAAA,EAAU;AACzB,MAAA,MAAM,SAAS,MAAA,CAAO,MAAA;AAEtB,MAAA,OAAO,MAAA,CAAO,eAAA,CAAgB,QAAA,EAAU,OAAO,IAAA,KAAS;AACtD,QAAA,IAAI;AAEF,UAAA,MAAM,GAAA,GAAoBC,qCAAmB,IAAI,CAAA;AAEjD,UAAA,MAAM,cAAe,IAAA,CAAgC,GAAA;AACrD,UAAA,IAAI;AACF,YAAC,KAAgC,GAAA,GAAM,GAAA;AACvC,YAAA,MAAM,MAAA,GAAS,MAAM,cAAA,CAAe,KAAA,CAAM,MAAM,IAAU,CAAA;AAC1D,YAAA,IAAA,CAAK,SAAA,CAAU,EAAE,IAAA,EAAMC,kBAAA,CAAe,IAAI,CAAA;AAC1C,YAAA,OAAO,MAAA;AAAA,UACT,CAAA,SAAE;AAEA,YAAA,IAAI,gBAAgB,KAAA,CAAA,EAAW;AAC7B,cAAA,OAAQ,IAAA,CAAgC,GAAA;AAAA,YAC1C,CAAA,MAAO;AACL,cAAC,KAAgC,GAAA,GAAM,WAAA;AAAA,YACzC;AAAA,UACF;AAAA,QACF,SAAS,KAAA,EAAO;AACd,UAAA,IAAA,CAAK,SAAA,CAAU;AAAA,YACb,MAAMA,kBAAA,CAAe,KAAA;AAAA,YACrB,OAAA,EAAS,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU;AAAA,WACnD,CAAA;AACD,UAAA,IAAA,CAAK,eAAA;AAAA,YACH,iBAAiB,KAAA,GAAQ,KAAA,GAAQ,IAAI,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC;AAAA,WAC1D;AACA,UAAA,MAAM,KAAA;AAAA,QACR,CAAA,SAAE;AACA,UAAA,IAAA,CAAK,GAAA,EAAI;AAAA,QACX;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,EACF,CAAA;AACF","file":"decorators.cjs","sourcesContent":["/**\n * TypeScript 5+ Decorators for autotel\n *\n * Provides @Trace decorator for class-based code.\n *\n * **Requires TypeScript 5.0+**\n *\n * @example Method decorator\n * ```typescript\n * import { Trace } from 'autotel/decorators'\n *\n * class OrderService {\n *   @Trace('order.create', { withMetrics: true })\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n *\n *   @Trace() // Uses method name as span name\n *   async processPayment(orderId: string) {\n *     return await stripe.charge(orderId)\n *   }\n * }\n * ```\n */\n\nimport type { TracingOptions, TraceContext } from './functional';\nimport { getConfig } from './config';\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { createTraceContext } from './trace-context';\n\n/**\n * Options for @Trace method decorator\n */\nexport interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {\n  /**\n   * Custom span name. If not provided, uses the method name.\n   */\n  name?: string;\n}\n\n/**\n * @Trace - Method decorator for fine-grained tracing\n *\n * Wraps a class method with automatic tracing. Supports both patterns:\n * - Simple: method doesn't use ctx\n * - Advanced: method accesses ctx via this.ctx\n *\n * @example Simple usage (no ctx)\n * ```typescript\n * class OrderService {\n *   @Trace()\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n * }\n * ```\n *\n * @example With custom name and options\n * ```typescript\n * class PaymentService {\n *   @Trace('payment.charge', { withMetrics: true })\n *   async chargeCard(amount: number) {\n *     return await stripe.charges.create({ amount })\n *   }\n * }\n * ```\n *\n * @example Accessing ctx\n * ```typescript\n * interface WithTraceContext {\n *   ctx?: TraceContext\n * }\n *\n * class UserService {\n *   @Trace()\n *   async createUser(data: UserData) {\n *     // Access ctx via this.ctx (available during execution)\n *     const ctx = (this as unknown as WithTraceContext).ctx\n *     if (ctx) {\n *       ctx.setAttribute('user.id', data.id)\n *     }\n *     return await db.users.create(data)\n *   }\n * }\n * ```\n */\nexport function Trace(\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  name?: string,\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  nameOrOptions?: string | TraceDecoratorOptions,\n  maybeOptions?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T {\n  // Parse arguments\n  const name =\n    typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions?.name;\n  // Options are used in the returned decorator function, not here\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const _options: TraceDecoratorOptions =\n    typeof nameOrOptions === 'string'\n      ? maybeOptions || {}\n      : nameOrOptions || {};\n\n  // TypeScript 5+ decorator signature\n  return function <T extends (...args: unknown[]) => Promise<unknown>>(\n    originalMethod: T,\n    context: ClassMethodDecoratorContext,\n  ): T {\n    const methodName = String(context.name);\n\n    // Skip if not an async function\n    // Check multiple ways to detect async functions (for different transpilation environments)\n    // TypeScript decorators run at class definition time, so we need robust detection\n    const methodStr = originalMethod?.toString() || '';\n    const isAsync =\n      originalMethod &&\n      (originalMethod.constructor?.name === 'AsyncFunction' ||\n        methodStr.trim().startsWith('async ') ||\n        (methodStr.includes('[native code]') && methodStr.includes('async')) ||\n        // Fallback: if function has async in its string representation\n        /async\\s+/.test(methodStr));\n\n    if (!isAsync) {\n      // Not an async function, return as-is\n      return originalMethod;\n    }\n\n    const spanName = name || methodName;\n\n    return async function <This>(\n      this: This,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(spanName, async (span) => {\n        try {\n          // Make ctx available via this.ctx for methods that need it\n          const ctx: TraceContext = createTraceContext(span);\n\n          const originalCtx = (this as { ctx?: TraceContext }).ctx;\n          try {\n            (this as { ctx?: TraceContext }).ctx = ctx;\n            const result = await originalMethod.apply(this, args as []);\n            span.setStatus({ code: SpanStatusCode.OK });\n            return result;\n          } finally {\n            // Restore original ctx\n            if (originalCtx === undefined) {\n              delete (this as { ctx?: TraceContext }).ctx;\n            } else {\n              (this as { ctx?: TraceContext }).ctx = originalCtx;\n            }\n          }\n        } catch (error) {\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    } as T;\n  };\n}\n\n// Re-export types for convenience\n\nexport { type TraceContext, type TracingOptions } from './functional';\n"]}
+{"version":3,"file":"decorators.cjs","names":["getConfig","createTraceContext","SpanStatusCode"],"sources":["../src/decorators.ts"],"sourcesContent":["/**\n * TypeScript 5+ Decorators for autotel\n *\n * Provides @Trace decorator for class-based code.\n *\n * **Requires TypeScript 5.0+**\n *\n * @example Method decorator\n * ```typescript\n * import { Trace } from 'autotel/decorators'\n *\n * class OrderService {\n *   @Trace('order.create', { withMetrics: true })\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n *\n *   @Trace() // Uses method name as span name\n *   async processPayment(orderId: string) {\n *     return await stripe.charge(orderId)\n *   }\n * }\n * ```\n */\n\nimport type { TracingOptions, TraceContext } from './functional';\nimport { getConfig } from './config';\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { createTraceContext } from './trace-context';\n\n/**\n * Options for @Trace method decorator\n */\nexport interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {\n  /**\n   * Custom span name. If not provided, uses the method name.\n   */\n  name?: string;\n}\n\n/**\n * @Trace - Method decorator for fine-grained tracing\n *\n * Wraps a class method with automatic tracing. Supports both patterns:\n * - Simple: method doesn't use ctx\n * - Advanced: method accesses ctx via this.ctx\n *\n * @example Simple usage (no ctx)\n * ```typescript\n * class OrderService {\n *   @Trace()\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n * }\n * ```\n *\n * @example With custom name and options\n * ```typescript\n * class PaymentService {\n *   @Trace('payment.charge', { withMetrics: true })\n *   async chargeCard(amount: number) {\n *     return await stripe.charges.create({ amount })\n *   }\n * }\n * ```\n *\n * @example Accessing ctx\n * ```typescript\n * interface WithTraceContext {\n *   ctx?: TraceContext\n * }\n *\n * class UserService {\n *   @Trace()\n *   async createUser(data: UserData) {\n *     // Access ctx via this.ctx (available during execution)\n *     const ctx = (this as unknown as WithTraceContext).ctx\n *     if (ctx) {\n *       ctx.setAttribute('user.id', data.id)\n *     }\n *     return await db.users.create(data)\n *   }\n * }\n * ```\n */\nexport function Trace(\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  name?: string,\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  nameOrOptions?: string | TraceDecoratorOptions,\n  maybeOptions?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T {\n  // Parse arguments\n  const name =\n    typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions?.name;\n  // Options are used in the returned decorator function, not here\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const _options: TraceDecoratorOptions =\n    typeof nameOrOptions === 'string'\n      ? maybeOptions || {}\n      : nameOrOptions || {};\n\n  // TypeScript 5+ decorator signature\n  return function <T extends (...args: unknown[]) => Promise<unknown>>(\n    originalMethod: T,\n    context: ClassMethodDecoratorContext,\n  ): T {\n    const methodName = String(context.name);\n\n    // Skip if not an async function\n    // Check multiple ways to detect async functions (for different transpilation environments)\n    // TypeScript decorators run at class definition time, so we need robust detection\n    const methodStr = originalMethod?.toString() || '';\n    const isAsync =\n      originalMethod &&\n      (originalMethod.constructor?.name === 'AsyncFunction' ||\n        methodStr.trim().startsWith('async ') ||\n        (methodStr.includes('[native code]') && methodStr.includes('async')) ||\n        // Fallback: if function has async in its string representation\n        /async\\s+/.test(methodStr));\n\n    if (!isAsync) {\n      // Not an async function, return as-is\n      return originalMethod;\n    }\n\n    const spanName = name || methodName;\n\n    return async function <This>(\n      this: This,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(spanName, async (span) => {\n        try {\n          // Make ctx available via this.ctx for methods that need it\n          const ctx: TraceContext = createTraceContext(span);\n\n          const originalCtx = (this as { ctx?: TraceContext }).ctx;\n          try {\n            (this as { ctx?: TraceContext }).ctx = ctx;\n            const result = await originalMethod.apply(this, args as []);\n            span.setStatus({ code: SpanStatusCode.OK });\n            return result;\n          } finally {\n            // Restore original ctx\n            if (originalCtx === undefined) {\n              delete (this as { ctx?: TraceContext }).ctx;\n            } else {\n              (this as { ctx?: TraceContext }).ctx = originalCtx;\n            }\n          }\n        } catch (error) {\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    } as T;\n  };\n}\n\n// Re-export types for convenience\n\nexport { type TraceContext, type TracingOptions } from './functional';\n"],"mappings":";;;;;;AAmGA,SAAgB,MACd,eACA,cAIK;CAEL,MAAM,OACJ,OAAO,kBAAkB,WAAW,gBAAgB,eAAe;CASrE,OAAO,SACL,gBACA,SACG;EACH,MAAM,aAAa,OAAO,QAAQ,IAAI;EAKtC,MAAM,YAAY,gBAAgB,SAAS,KAAK;EAShD,IAAI,EAPF,mBACC,eAAe,aAAa,SAAS,mBACpC,UAAU,KAAK,CAAC,CAAC,WAAW,QAAQ,KACnC,UAAU,SAAS,eAAe,KAAK,UAAU,SAAS,OAAO,KAElE,WAAW,KAAK,SAAS,KAI3B,OAAO;EAGT,MAAM,WAAW,QAAQ;EAEzB,OAAO,eAEL,GAAG,MACe;GAIlB,OAHeA,yBACK,CAAC,CAAC,OAER,gBAAgB,UAAU,OAAO,SAAS;IACtD,IAAI;KAEF,MAAM,MAAoBC,iCAAmB,IAAI;KAEjD,MAAM,cAAe,KAAgC;KACrD,IAAI;MACF,AAAC,KAAgC,MAAM;MACvC,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAU;MAC1D,KAAK,UAAU,EAAE,MAAMC,kCAAe,GAAG,CAAC;MAC1C,OAAO;KACT,UAAU;MAER,IAAI,gBAAgB,QAClB,OAAQ,KAAgC;WAExC,AAAC,KAAgC,MAAM;KAE3C;IACF,SAAS,OAAO;KACd,KAAK,UAAU;MACb,MAAMA,kCAAe;MACrB,SAAS,iBAAiB,QAAQ,MAAM,UAAU;KACpD,CAAC;KACD,KAAK,gBACH,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAC1D;KACA,MAAM;IACR,UAAU;KACR,KAAK,IAAI;IACX;GACF,CAAC;EACH;CACF;AACF"}

package/dist/decorators.d.cts

@@ -1,43 +1,15 @@
-import { TracingOptions } from './functional.cjs';
-export { T as TraceContext } from './trace-context-DbGKd1Rn.cjs';
-import '@opentelemetry/api';
-import './sampling.cjs';
-import './logger.cjs';
-import 'pino';
-
-/**
- * TypeScript 5+ Decorators for autotel
- *
- * Provides @Trace decorator for class-based code.
- *
- * **Requires TypeScript 5.0+**
- *
- * @example Method decorator
- * ```typescript
- * import { Trace } from 'autotel/decorators'
- *
- * class OrderService {
- *   @Trace('order.create', { withMetrics: true })
- *   async createOrder(data: OrderData) {
- *     return await db.orders.create(data)
- *   }
- *
- *   @Trace() // Uses method name as span name
- *   async processPayment(orderId: string) {
- *     return await stripe.charge(orderId)
- *   }
- * }
- * ```
- */
+import { n as TraceContext } from "./trace-context-Cijqoi6e.cjs";
+import { TracingOptions } from "./functional.cjs";
 
+//#region src/decorators.d.ts
 /**
  * Options for @Trace method decorator
  */
 interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {
-    /**
-     * Custom span name. If not provided, uses the method name.
-     */
-    name?: string;
+  /**
+   * Custom span name. If not provided, uses the method name.
+   */
+  name?: string;
 }
 /**
  * @Trace - Method decorator for fine-grained tracing
@@ -87,5 +59,6 @@ interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {
  */
 declare function Trace(options?: TraceDecoratorOptions): <T extends (...args: unknown[]) => Promise<unknown>>(originalMethod: T, context: ClassMethodDecoratorContext) => T;
 declare function Trace(name?: string, options?: TraceDecoratorOptions): <T extends (...args: unknown[]) => Promise<unknown>>(originalMethod: T, context: ClassMethodDecoratorContext) => T;
-
-export { Trace, type TraceDecoratorOptions, TracingOptions };
+//#endregion
+export { Trace, type TraceContext, TraceDecoratorOptions, type TracingOptions };
+//# sourceMappingURL=decorators.d.cts.map

package/dist/decorators.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.cts","names":[],"sources":["../src/decorators.ts"],"mappings":";;;;;;;UAiCiB,qBAAA,SAA8B,IAAI,CAAC,cAAA;EAwDlD;;;EApDA,IAAA;AAAA;AAsDI;AACN;;;;;;;;;;;;;;;;;;;;;;AAMM;;;;;;;;;;;;;;;;;;;;;;;AAPA,iBALU,KAAA,CACd,OAAA,GAAU,qBAAA,kBACM,IAAA,gBAAoB,OAAA,WACpC,cAAA,EAAgB,CAAA,EAChB,OAAA,EAAS,2BAAA,KACN,CAAA;AAAA,iBACW,KAAA,CACd,IAAA,WACA,OAAA,GAAU,qBAAA,kBACM,IAAA,gBAAoB,OAAA,WACpC,cAAA,EAAgB,CAAA,EAChB,OAAA,EAAS,2BAAA,KACN,CAAA"}

package/dist/decorators.d.ts

@@ -1,43 +1,15 @@
-import { TracingOptions } from './functional.js';
-export { T as TraceContext } from './trace-context-DbGKd1Rn.js';
-import '@opentelemetry/api';
-import './sampling.js';
-import './logger.js';
-import 'pino';
-
-/**
- * TypeScript 5+ Decorators for autotel
- *
- * Provides @Trace decorator for class-based code.
- *
- * **Requires TypeScript 5.0+**
- *
- * @example Method decorator
- * ```typescript
- * import { Trace } from 'autotel/decorators'
- *
- * class OrderService {
- *   @Trace('order.create', { withMetrics: true })
- *   async createOrder(data: OrderData) {
- *     return await db.orders.create(data)
- *   }
- *
- *   @Trace() // Uses method name as span name
- *   async processPayment(orderId: string) {
- *     return await stripe.charge(orderId)
- *   }
- * }
- * ```
- */
+import { n as TraceContext } from "./trace-context-Cijqoi6e.js";
+import { TracingOptions } from "./functional.js";
 
+//#region src/decorators.d.ts
 /**
  * Options for @Trace method decorator
  */
 interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {
-    /**
-     * Custom span name. If not provided, uses the method name.
-     */
-    name?: string;
+  /**
+   * Custom span name. If not provided, uses the method name.
+   */
+  name?: string;
 }
 /**
  * @Trace - Method decorator for fine-grained tracing
@@ -87,5 +59,6 @@ interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {
  */
 declare function Trace(options?: TraceDecoratorOptions): <T extends (...args: unknown[]) => Promise<unknown>>(originalMethod: T, context: ClassMethodDecoratorContext) => T;
 declare function Trace(name?: string, options?: TraceDecoratorOptions): <T extends (...args: unknown[]) => Promise<unknown>>(originalMethod: T, context: ClassMethodDecoratorContext) => T;
-
-export { Trace, type TraceDecoratorOptions, TracingOptions };
+//#endregion
+export { Trace, type TraceContext, TraceDecoratorOptions, type TracingOptions };
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","names":[],"sources":["../src/decorators.ts"],"mappings":";;;;;;;UAiCiB,qBAAA,SAA8B,IAAI,CAAC,cAAA;EAwDlD;;;EApDA,IAAA;AAAA;AAsDI;AACN;;;;;;;;;;;;;;;;;;;;;;AAMM;;;;;;;;;;;;;;;;;;;;;;;AAPA,iBALU,KAAA,CACd,OAAA,GAAU,qBAAA,kBACM,IAAA,gBAAoB,OAAA,WACpC,cAAA,EAAgB,CAAA,EAChB,OAAA,EAAS,2BAAA,KACN,CAAA;AAAA,iBACW,KAAA,CACd,IAAA,WACA,OAAA,GAAU,qBAAA,kBACM,IAAA,gBAAoB,OAAA,WACpC,cAAA,EAAgB,CAAA,EAChB,OAAA,EAAS,2BAAA,KACN,CAAA"}

package/dist/decorators.js

@@ -1,69 +1,44 @@
-import './chunk-YWCESU4Y.js';
-import './chunk-HT5JQKN2.js';
-import './chunk-SEO6NAQT.js';
-import { createTraceContext } from './chunk-O4JZUCUE.js';
-import './chunk-ALPYR2GC.js';
-import './chunk-CMHVQR6P.js';
-import './chunk-A4E5AQFK.js';
-import './chunk-WGWSHJ2N.js';
-import './chunk-GYR5K654.js';
-import './chunk-RUPKBKUF.js';
-import './chunk-6UQRVUN3.js';
-import './chunk-3QXBFGKP.js';
-import './chunk-Q4EULJQY.js';
-import './chunk-DPSA4QLA.js';
-import './chunk-55ER2KD5.js';
-import { getConfig } from './chunk-J5QENANM.js';
-import './chunk-HA2WBOGQ.js';
-import { SpanStatusCode } from '@opentelemetry/api';
+import { getConfig } from "./config.js";
+import { p as createTraceContext } from "./track-nsKVy-pj.js";
+import { SpanStatusCode } from "@opentelemetry/api";
 
+//#region src/decorators.ts
 function Trace(nameOrOptions, maybeOptions) {
-  const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
-  return function(originalMethod, context) {
-    const methodName = String(context.name);
-    const methodStr = originalMethod?.toString() || "";
-    const isAsync = originalMethod && (originalMethod.constructor?.name === "AsyncFunction" || methodStr.trim().startsWith("async ") || methodStr.includes("[native code]") && methodStr.includes("async") || // Fallback: if function has async in its string representation
-    /async\s+/.test(methodStr));
-    if (!isAsync) {
-      return originalMethod;
-    }
-    const spanName = name || methodName;
-    return async function(...args) {
-      const config = getConfig();
-      const tracer = config.tracer;
-      return tracer.startActiveSpan(spanName, async (span) => {
-        try {
-          const ctx = createTraceContext(span);
-          const originalCtx = this.ctx;
-          try {
-            this.ctx = ctx;
-            const result = await originalMethod.apply(this, args);
-            span.setStatus({ code: SpanStatusCode.OK });
-            return result;
-          } finally {
-            if (originalCtx === void 0) {
-              delete this.ctx;
-            } else {
-              this.ctx = originalCtx;
-            }
-          }
-        } catch (error) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : "Unknown error"
-          });
-          span.recordException(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          throw error;
-        } finally {
-          span.end();
-        }
-      });
-    };
-  };
+	const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
+	return function(originalMethod, context) {
+		const methodName = String(context.name);
+		const methodStr = originalMethod?.toString() || "";
+		if (!(originalMethod && (originalMethod.constructor?.name === "AsyncFunction" || methodStr.trim().startsWith("async ") || methodStr.includes("[native code]") && methodStr.includes("async") || /async\s+/.test(methodStr)))) return originalMethod;
+		const spanName = name || methodName;
+		return async function(...args) {
+			return getConfig().tracer.startActiveSpan(spanName, async (span) => {
+				try {
+					const ctx = createTraceContext(span);
+					const originalCtx = this.ctx;
+					try {
+						this.ctx = ctx;
+						const result = await originalMethod.apply(this, args);
+						span.setStatus({ code: SpanStatusCode.OK });
+						return result;
+					} finally {
+						if (originalCtx === void 0) delete this.ctx;
+						else this.ctx = originalCtx;
+					}
+				} catch (error) {
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : "Unknown error"
+					});
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+	};
 }
 
+//#endregion
 export { Trace };
-//# sourceMappingURL=decorators.js.map
 //# sourceMappingURL=decorators.js.map

package/dist/decorators.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/decorators.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAmGO,SAAS,KAAA,CACd,eACA,YAAA,EAIK;AAEL,EAAA,MAAM,IAAA,GACJ,OAAO,aAAA,KAAkB,QAAA,GAAW,gBAAgB,aAAA,EAAe,IAAA;AASrE,EAAA,OAAO,SACL,gBACA,OAAA,EACG;AACH,IAAA,MAAM,UAAA,GAAa,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA;AAKtC,IAAA,MAAM,SAAA,GAAY,cAAA,EAAgB,QAAA,EAAS,IAAK,EAAA;AAChD,IAAA,MAAM,UACJ,cAAA,KACC,cAAA,CAAe,aAAa,IAAA,KAAS,eAAA,IACpC,UAAU,IAAA,EAAK,CAAE,UAAA,CAAW,QAAQ,KACnC,SAAA,CAAU,QAAA,CAAS,eAAe,CAAA,IAAK,SAAA,CAAU,SAAS,OAAO,CAAA;AAAA,IAElE,UAAA,CAAW,KAAK,SAAS,CAAA,CAAA;AAE7B,IAAA,IAAI,CAAC,OAAA,EAAS;AAEZ,MAAA,OAAO,cAAA;AAAA,IACT;AAEA,IAAA,MAAM,WAAW,IAAA,IAAQ,UAAA;AAEzB,IAAA,OAAO,kBAEF,IAAA,EACe;AAClB,MAAA,MAAM,SAAS,SAAA,EAAU;AACzB,MAAA,MAAM,SAAS,MAAA,CAAO,MAAA;AAEtB,MAAA,OAAO,MAAA,CAAO,eAAA,CAAgB,QAAA,EAAU,OAAO,IAAA,KAAS;AACtD,QAAA,IAAI;AAEF,UAAA,MAAM,GAAA,GAAoB,mBAAmB,IAAI,CAAA;AAEjD,UAAA,MAAM,cAAe,IAAA,CAAgC,GAAA;AACrD,UAAA,IAAI;AACF,YAAC,KAAgC,GAAA,GAAM,GAAA;AACvC,YAAA,MAAM,MAAA,GAAS,MAAM,cAAA,CAAe,KAAA,CAAM,MAAM,IAAU,CAAA;AAC1D,YAAA,IAAA,CAAK,SAAA,CAAU,EAAE,IAAA,EAAM,cAAA,CAAe,IAAI,CAAA;AAC1C,YAAA,OAAO,MAAA;AAAA,UACT,CAAA,SAAE;AAEA,YAAA,IAAI,gBAAgB,KAAA,CAAA,EAAW;AAC7B,cAAA,OAAQ,IAAA,CAAgC,GAAA;AAAA,YAC1C,CAAA,MAAO;AACL,cAAC,KAAgC,GAAA,GAAM,WAAA;AAAA,YACzC;AAAA,UACF;AAAA,QACF,SAAS,KAAA,EAAO;AACd,UAAA,IAAA,CAAK,SAAA,CAAU;AAAA,YACb,MAAM,cAAA,CAAe,KAAA;AAAA,YACrB,OAAA,EAAS,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU;AAAA,WACnD,CAAA;AACD,UAAA,IAAA,CAAK,eAAA;AAAA,YACH,iBAAiB,KAAA,GAAQ,KAAA,GAAQ,IAAI,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC;AAAA,WAC1D;AACA,UAAA,MAAM,KAAA;AAAA,QACR,CAAA,SAAE;AACA,UAAA,IAAA,CAAK,GAAA,EAAI;AAAA,QACX;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,EACF,CAAA;AACF","file":"decorators.js","sourcesContent":["/**\n * TypeScript 5+ Decorators for autotel\n *\n * Provides @Trace decorator for class-based code.\n *\n * **Requires TypeScript 5.0+**\n *\n * @example Method decorator\n * ```typescript\n * import { Trace } from 'autotel/decorators'\n *\n * class OrderService {\n *   @Trace('order.create', { withMetrics: true })\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n *\n *   @Trace() // Uses method name as span name\n *   async processPayment(orderId: string) {\n *     return await stripe.charge(orderId)\n *   }\n * }\n * ```\n */\n\nimport type { TracingOptions, TraceContext } from './functional';\nimport { getConfig } from './config';\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { createTraceContext } from './trace-context';\n\n/**\n * Options for @Trace method decorator\n */\nexport interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {\n  /**\n   * Custom span name. If not provided, uses the method name.\n   */\n  name?: string;\n}\n\n/**\n * @Trace - Method decorator for fine-grained tracing\n *\n * Wraps a class method with automatic tracing. Supports both patterns:\n * - Simple: method doesn't use ctx\n * - Advanced: method accesses ctx via this.ctx\n *\n * @example Simple usage (no ctx)\n * ```typescript\n * class OrderService {\n *   @Trace()\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n * }\n * ```\n *\n * @example With custom name and options\n * ```typescript\n * class PaymentService {\n *   @Trace('payment.charge', { withMetrics: true })\n *   async chargeCard(amount: number) {\n *     return await stripe.charges.create({ amount })\n *   }\n * }\n * ```\n *\n * @example Accessing ctx\n * ```typescript\n * interface WithTraceContext {\n *   ctx?: TraceContext\n * }\n *\n * class UserService {\n *   @Trace()\n *   async createUser(data: UserData) {\n *     // Access ctx via this.ctx (available during execution)\n *     const ctx = (this as unknown as WithTraceContext).ctx\n *     if (ctx) {\n *       ctx.setAttribute('user.id', data.id)\n *     }\n *     return await db.users.create(data)\n *   }\n * }\n * ```\n */\nexport function Trace(\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  name?: string,\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  nameOrOptions?: string | TraceDecoratorOptions,\n  maybeOptions?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T {\n  // Parse arguments\n  const name =\n    typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions?.name;\n  // Options are used in the returned decorator function, not here\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const _options: TraceDecoratorOptions =\n    typeof nameOrOptions === 'string'\n      ? maybeOptions || {}\n      : nameOrOptions || {};\n\n  // TypeScript 5+ decorator signature\n  return function <T extends (...args: unknown[]) => Promise<unknown>>(\n    originalMethod: T,\n    context: ClassMethodDecoratorContext,\n  ): T {\n    const methodName = String(context.name);\n\n    // Skip if not an async function\n    // Check multiple ways to detect async functions (for different transpilation environments)\n    // TypeScript decorators run at class definition time, so we need robust detection\n    const methodStr = originalMethod?.toString() || '';\n    const isAsync =\n      originalMethod &&\n      (originalMethod.constructor?.name === 'AsyncFunction' ||\n        methodStr.trim().startsWith('async ') ||\n        (methodStr.includes('[native code]') && methodStr.includes('async')) ||\n        // Fallback: if function has async in its string representation\n        /async\\s+/.test(methodStr));\n\n    if (!isAsync) {\n      // Not an async function, return as-is\n      return originalMethod;\n    }\n\n    const spanName = name || methodName;\n\n    return async function <This>(\n      this: This,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(spanName, async (span) => {\n        try {\n          // Make ctx available via this.ctx for methods that need it\n          const ctx: TraceContext = createTraceContext(span);\n\n          const originalCtx = (this as { ctx?: TraceContext }).ctx;\n          try {\n            (this as { ctx?: TraceContext }).ctx = ctx;\n            const result = await originalMethod.apply(this, args as []);\n            span.setStatus({ code: SpanStatusCode.OK });\n            return result;\n          } finally {\n            // Restore original ctx\n            if (originalCtx === undefined) {\n              delete (this as { ctx?: TraceContext }).ctx;\n            } else {\n              (this as { ctx?: TraceContext }).ctx = originalCtx;\n            }\n          }\n        } catch (error) {\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    } as T;\n  };\n}\n\n// Re-export types for convenience\n\nexport { type TraceContext, type TracingOptions } from './functional';\n"]}
+{"version":3,"file":"decorators.js","names":[],"sources":["../src/decorators.ts"],"sourcesContent":["/**\n * TypeScript 5+ Decorators for autotel\n *\n * Provides @Trace decorator for class-based code.\n *\n * **Requires TypeScript 5.0+**\n *\n * @example Method decorator\n * ```typescript\n * import { Trace } from 'autotel/decorators'\n *\n * class OrderService {\n *   @Trace('order.create', { withMetrics: true })\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n *\n *   @Trace() // Uses method name as span name\n *   async processPayment(orderId: string) {\n *     return await stripe.charge(orderId)\n *   }\n * }\n * ```\n */\n\nimport type { TracingOptions, TraceContext } from './functional';\nimport { getConfig } from './config';\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { createTraceContext } from './trace-context';\n\n/**\n * Options for @Trace method decorator\n */\nexport interface TraceDecoratorOptions extends Omit<TracingOptions, 'name'> {\n  /**\n   * Custom span name. If not provided, uses the method name.\n   */\n  name?: string;\n}\n\n/**\n * @Trace - Method decorator for fine-grained tracing\n *\n * Wraps a class method with automatic tracing. Supports both patterns:\n * - Simple: method doesn't use ctx\n * - Advanced: method accesses ctx via this.ctx\n *\n * @example Simple usage (no ctx)\n * ```typescript\n * class OrderService {\n *   @Trace()\n *   async createOrder(data: OrderData) {\n *     return await db.orders.create(data)\n *   }\n * }\n * ```\n *\n * @example With custom name and options\n * ```typescript\n * class PaymentService {\n *   @Trace('payment.charge', { withMetrics: true })\n *   async chargeCard(amount: number) {\n *     return await stripe.charges.create({ amount })\n *   }\n * }\n * ```\n *\n * @example Accessing ctx\n * ```typescript\n * interface WithTraceContext {\n *   ctx?: TraceContext\n * }\n *\n * class UserService {\n *   @Trace()\n *   async createUser(data: UserData) {\n *     // Access ctx via this.ctx (available during execution)\n *     const ctx = (this as unknown as WithTraceContext).ctx\n *     if (ctx) {\n *       ctx.setAttribute('user.id', data.id)\n *     }\n *     return await db.users.create(data)\n *   }\n * }\n * ```\n */\nexport function Trace(\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  name?: string,\n  options?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T;\nexport function Trace(\n  nameOrOptions?: string | TraceDecoratorOptions,\n  maybeOptions?: TraceDecoratorOptions,\n): <T extends (...args: unknown[]) => Promise<unknown>>(\n  originalMethod: T,\n  context: ClassMethodDecoratorContext,\n) => T {\n  // Parse arguments\n  const name =\n    typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions?.name;\n  // Options are used in the returned decorator function, not here\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const _options: TraceDecoratorOptions =\n    typeof nameOrOptions === 'string'\n      ? maybeOptions || {}\n      : nameOrOptions || {};\n\n  // TypeScript 5+ decorator signature\n  return function <T extends (...args: unknown[]) => Promise<unknown>>(\n    originalMethod: T,\n    context: ClassMethodDecoratorContext,\n  ): T {\n    const methodName = String(context.name);\n\n    // Skip if not an async function\n    // Check multiple ways to detect async functions (for different transpilation environments)\n    // TypeScript decorators run at class definition time, so we need robust detection\n    const methodStr = originalMethod?.toString() || '';\n    const isAsync =\n      originalMethod &&\n      (originalMethod.constructor?.name === 'AsyncFunction' ||\n        methodStr.trim().startsWith('async ') ||\n        (methodStr.includes('[native code]') && methodStr.includes('async')) ||\n        // Fallback: if function has async in its string representation\n        /async\\s+/.test(methodStr));\n\n    if (!isAsync) {\n      // Not an async function, return as-is\n      return originalMethod;\n    }\n\n    const spanName = name || methodName;\n\n    return async function <This>(\n      this: This,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(spanName, async (span) => {\n        try {\n          // Make ctx available via this.ctx for methods that need it\n          const ctx: TraceContext = createTraceContext(span);\n\n          const originalCtx = (this as { ctx?: TraceContext }).ctx;\n          try {\n            (this as { ctx?: TraceContext }).ctx = ctx;\n            const result = await originalMethod.apply(this, args as []);\n            span.setStatus({ code: SpanStatusCode.OK });\n            return result;\n          } finally {\n            // Restore original ctx\n            if (originalCtx === undefined) {\n              delete (this as { ctx?: TraceContext }).ctx;\n            } else {\n              (this as { ctx?: TraceContext }).ctx = originalCtx;\n            }\n          }\n        } catch (error) {\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.recordException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    } as T;\n  };\n}\n\n// Re-export types for convenience\n\nexport { type TraceContext, type TracingOptions } from './functional';\n"],"mappings":";;;;;AAmGA,SAAgB,MACd,eACA,cAIK;CAEL,MAAM,OACJ,OAAO,kBAAkB,WAAW,gBAAgB,eAAe;CASrE,OAAO,SACL,gBACA,SACG;EACH,MAAM,aAAa,OAAO,QAAQ,IAAI;EAKtC,MAAM,YAAY,gBAAgB,SAAS,KAAK;EAShD,IAAI,EAPF,mBACC,eAAe,aAAa,SAAS,mBACpC,UAAU,KAAK,CAAC,CAAC,WAAW,QAAQ,KACnC,UAAU,SAAS,eAAe,KAAK,UAAU,SAAS,OAAO,KAElE,WAAW,KAAK,SAAS,KAI3B,OAAO;EAGT,MAAM,WAAW,QAAQ;EAEzB,OAAO,eAEL,GAAG,MACe;GAIlB,OAHe,UACK,CAAC,CAAC,OAER,gBAAgB,UAAU,OAAO,SAAS;IACtD,IAAI;KAEF,MAAM,MAAoB,mBAAmB,IAAI;KAEjD,MAAM,cAAe,KAAgC;KACrD,IAAI;MACF,AAAC,KAAgC,MAAM;MACvC,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAU;MAC1D,KAAK,UAAU,EAAE,MAAM,eAAe,GAAG,CAAC;MAC1C,OAAO;KACT,UAAU;MAER,IAAI,gBAAgB,QAClB,OAAQ,KAAgC;WAExC,AAAC,KAAgC,MAAM;KAE3C;IACF,SAAS,OAAO;KACd,KAAK,UAAU;MACb,MAAM,eAAe;MACrB,SAAS,iBAAiB,QAAQ,MAAM,UAAU;KACpD,CAAC;KACD,KAAK,gBACH,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAC1D;KACA,MAAM;IACR,UAAU;KACR,KAAK,IAAI;IACX;GACF,CAAC;EACH;CACF;AACF"}

package/dist/define-event-CreknLm3.d.ts

@@ -0,0 +1,25 @@
+import { i as EventSchemaMetadata } from "./event-subscriber-D1XLkPzi.js";
+
+//#region src/define-event.d.ts
+type SafeParseResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: unknown;
+};
+interface SchemaLike<T> {
+  safeParse(input: unknown): SafeParseResult<T>;
+}
+interface DefineEventOptions<S> {
+  toJsonSchema?: (schema: S) => unknown;
+}
+interface DefinedEvent<Name extends string, Payload> {
+  readonly name: Name;
+  readonly schemaMetadata?: EventSchemaMetadata;
+  track(payload: Payload): void;
+}
+declare function defineEvent<Name extends string, Payload, S extends SchemaLike<Payload>>(name: Name, schema: S, options?: DefineEventOptions<S>): DefinedEvent<Name, Payload>;
+//#endregion
+export { defineEvent as i, DefinedEvent as n, SchemaLike as r, DefineEventOptions as t };
+//# sourceMappingURL=define-event-CreknLm3.d.ts.map

package/dist/define-event-CreknLm3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-event-CreknLm3.d.ts","names":[],"sources":["../src/define-event.ts"],"mappings":";;;KAIK,eAAA;EACC,OAAA;EAAe,IAAA,EAAM,CAAC;AAAA;EACtB,OAAA;EAAgB,KAAA;AAAA;AAAA,UAEL,UAAA;EACf,SAAA,CAAU,KAAA,YAAiB,eAAe,CAAC,CAAA;AAAA;AAAA,UAG5B,kBAAA;EACf,YAAA,IAAgB,MAAA,EAAQ,CAAC;AAAA;AAAA,UAGV,YAAA;EAAA,SACN,IAAA,EAAM,IAAA;EAAA,SACN,cAAA,GAAiB,mBAAA;EAC1B,KAAA,CAAM,OAAA,EAAS,OAAA;AAAA;AAAA,iBAGD,WAAA,yCAGJ,UAAA,CAAW,OAAA,GAErB,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,kBAAA,CAAmB,CAAA,IAC3B,YAAA,CAAa,IAAA,EAAM,OAAA"}

package/dist/define-event-HZRizPwz.d.cts

@@ -0,0 +1,25 @@
+import { i as EventSchemaMetadata } from "./event-subscriber-D1XLkPzi.cjs";
+
+//#region src/define-event.d.ts
+type SafeParseResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: unknown;
+};
+interface SchemaLike<T> {
+  safeParse(input: unknown): SafeParseResult<T>;
+}
+interface DefineEventOptions<S> {
+  toJsonSchema?: (schema: S) => unknown;
+}
+interface DefinedEvent<Name extends string, Payload> {
+  readonly name: Name;
+  readonly schemaMetadata?: EventSchemaMetadata;
+  track(payload: Payload): void;
+}
+declare function defineEvent<Name extends string, Payload, S extends SchemaLike<Payload>>(name: Name, schema: S, options?: DefineEventOptions<S>): DefinedEvent<Name, Payload>;
+//#endregion
+export { defineEvent as i, DefinedEvent as n, SchemaLike as r, DefineEventOptions as t };
+//# sourceMappingURL=define-event-HZRizPwz.d.cts.map

package/dist/define-event-HZRizPwz.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-event-HZRizPwz.d.cts","names":[],"sources":["../src/define-event.ts"],"mappings":";;;KAIK,eAAA;EACC,OAAA;EAAe,IAAA,EAAM,CAAC;AAAA;EACtB,OAAA;EAAgB,KAAA;AAAA;AAAA,UAEL,UAAA;EACf,SAAA,CAAU,KAAA,YAAiB,eAAe,CAAC,CAAA;AAAA;AAAA,UAG5B,kBAAA;EACf,YAAA,IAAgB,MAAA,EAAQ,CAAC;AAAA;AAAA,UAGV,YAAA;EAAA,SACN,IAAA,EAAM,IAAA;EAAA,SACN,cAAA,GAAiB,mBAAA;EAC1B,KAAA,CAAM,OAAA,EAAS,OAAA;AAAA;AAAA,iBAGD,WAAA,yCAGJ,UAAA,CAAW,OAAA,GAErB,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,kBAAA,CAAmB,CAAA,IAC3B,YAAA,CAAa,IAAA,EAAM,OAAA"}

package/dist/drain-pipeline.cjs

@@ -1,12 +1,114 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-var chunk7EQ4G4SI_cjs = require('./chunk-7EQ4G4SI.cjs');
+//#region src/drain-pipeline.ts
+function wait(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function createDrainPipeline(options) {
+	const batchSize = options?.batch?.size ?? 50;
+	const intervalMs = options?.batch?.intervalMs ?? 5e3;
+	const maxBufferSize = options?.maxBufferSize ?? 1e3;
+	const maxAttempts = options?.retry?.maxAttempts ?? 3;
+	const backoff = options?.retry?.backoff ?? "exponential";
+	const initialDelayMs = options?.retry?.initialDelayMs ?? 1e3;
+	const maxDelayMs = options?.retry?.maxDelayMs ?? 3e4;
+	const jitter = options?.retry?.jitter ?? true;
+	const dropPolicy = options?.dropPolicy ?? "oldest";
+	const onDropped = options?.onDropped;
+	if (!Number.isFinite(batchSize) || batchSize <= 0) throw new Error(`[autotel/drain-pipeline] batch.size must be a positive finite number, got: ${batchSize}`);
+	if (!Number.isFinite(intervalMs) || intervalMs <= 0) throw new Error(`[autotel/drain-pipeline] batch.intervalMs must be a positive finite number, got: ${intervalMs}`);
+	if (!Number.isFinite(maxBufferSize) || maxBufferSize <= 0) throw new Error(`[autotel/drain-pipeline] maxBufferSize must be a positive finite number, got: ${maxBufferSize}`);
+	if (!Number.isFinite(maxAttempts) || maxAttempts <= 0) throw new Error(`[autotel/drain-pipeline] retry.maxAttempts must be a positive finite number, got: ${maxAttempts}`);
+	return (drain) => {
+		const buffer = [];
+		let timer = null;
+		let activeFlush = null;
+		let isShutdown = false;
+		const clearTimer = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+		};
+		const computeDelay = (attempt) => {
+			const base = backoff === "fixed" ? initialDelayMs : backoff === "linear" ? initialDelayMs * attempt : initialDelayMs * 2 ** (attempt - 1);
+			const bounded = Math.min(base, maxDelayMs);
+			if (!jitter || bounded <= 0) return bounded;
+			const factor = .5 + Math.random();
+			return Math.max(0, Math.round(bounded * factor));
+		};
+		const sendWithRetry = async (batch) => {
+			let lastError;
+			for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+				await drain(batch);
+				return;
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+				if (attempt < maxAttempts) await wait(computeDelay(attempt));
+			}
+			onDropped?.(batch, lastError);
+		};
+		const drainBuffer = async () => {
+			while (buffer.length > 0) await sendWithRetry(buffer.splice(0, batchSize));
+		};
+		const scheduleFlush = () => {
+			if (isShutdown || timer || activeFlush) return;
+			timer = setTimeout(() => {
+				timer = null;
+				startFlush();
+			}, intervalMs);
+			timer.unref?.();
+		};
+		const startFlush = () => {
+			if (activeFlush || isShutdown) return;
+			activeFlush = drainBuffer().finally(() => {
+				activeFlush = null;
+				if (isShutdown) return;
+				if (buffer.length >= batchSize) startFlush();
+				else if (buffer.length > 0) scheduleFlush();
+			});
+		};
+		const push = (ctx) => {
+			if (isShutdown) return;
+			if (buffer.length >= maxBufferSize) {
+				if (dropPolicy === "newest") {
+					onDropped?.([ctx]);
+					return;
+				}
+				const dropped = buffer.splice(0, 1);
+				onDropped?.(dropped);
+			}
+			buffer.push(ctx);
+			if (buffer.length >= batchSize) {
+				clearTimer();
+				startFlush();
+			} else scheduleFlush();
+		};
+		const flush = async () => {
+			clearTimer();
+			if (activeFlush) await activeFlush;
+			const snapshot = buffer.length;
+			if (snapshot <= 0) return;
+			const toFlush = buffer.splice(0, snapshot);
+			while (toFlush.length > 0) await sendWithRetry(toFlush.splice(0, batchSize));
+		};
+		const shutdown = async () => {
+			isShutdown = true;
+			await flush();
+		};
+		const fn = push;
+		fn.flush = flush;
+		fn.shutdown = shutdown;
+		Object.defineProperty(fn, "pending", {
+			enumerable: true,
+			get: () => buffer.length
+		});
+		return fn;
+	};
+}
 
-
-
-Object.defineProperty(exports, "createDrainPipeline", {
-  enumerable: true,
-  get: function () { return chunk7EQ4G4SI_cjs.createDrainPipeline; }
-});
-//# sourceMappingURL=drain-pipeline.cjs.map
+//#endregion
+exports.createDrainPipeline = createDrainPipeline;
 //# sourceMappingURL=drain-pipeline.cjs.map

package/dist/drain-pipeline.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"drain-pipeline.cjs"}
+{"version":3,"file":"drain-pipeline.cjs","names":[],"sources":["../src/drain-pipeline.ts"],"sourcesContent":["export interface DrainPipelineOptions<T = unknown> {\n  batch?: {\n    /** Maximum events per batch. @default 50 */\n    size?: number;\n    /** Max time an event can stay buffered before flush. @default 5000 */\n    intervalMs?: number;\n  };\n  retry?: {\n    /** Total attempts including first try. @default 3 */\n    maxAttempts?: number;\n    /** Delay strategy between attempts. @default 'exponential' */\n    backoff?: 'exponential' | 'linear' | 'fixed';\n    /** Base delay for first retry. @default 1000 */\n    initialDelayMs?: number;\n    /** Max delay cap. @default 30000 */\n    maxDelayMs?: number;\n    /** Add random jitter to delays. @default true */\n    jitter?: boolean;\n  };\n  /** Max buffered events before dropping. @default 1000 */\n  maxBufferSize?: number;\n  /** Overflow policy. @default 'oldest' */\n  dropPolicy?: 'oldest' | 'newest';\n  /** Called when events are dropped from overflow or exhausted retries. */\n  onDropped?: (events: T[], error?: Error) => void;\n}\n\nexport interface PipelineDrainFn<T> {\n  (ctx: T): void;\n  /** Flush all buffered events. */\n  flush: () => Promise<void>;\n  /** Flush and stop scheduling future timer work. */\n  shutdown: () => Promise<void>;\n  readonly pending: number;\n}\n\nfunction wait(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    const timer = setTimeout(resolve, ms);\n    timer.unref?.();\n  });\n}\n\nexport function createDrainPipeline<T = unknown>(\n  options?: DrainPipelineOptions<T>,\n): (drain: (batch: T[]) => void | Promise<void>) => PipelineDrainFn<T> {\n  const batchSize = options?.batch?.size ?? 50;\n  const intervalMs = options?.batch?.intervalMs ?? 5000;\n  const maxBufferSize = options?.maxBufferSize ?? 1000;\n  const maxAttempts = options?.retry?.maxAttempts ?? 3;\n  const backoff = options?.retry?.backoff ?? 'exponential';\n  const initialDelayMs = options?.retry?.initialDelayMs ?? 1000;\n  const maxDelayMs = options?.retry?.maxDelayMs ?? 30_000;\n  const jitter = options?.retry?.jitter ?? true;\n  const dropPolicy = options?.dropPolicy ?? 'oldest';\n  const onDropped = options?.onDropped;\n\n  if (!Number.isFinite(batchSize) || batchSize <= 0) {\n    throw new Error(\n      `[autotel/drain-pipeline] batch.size must be a positive finite number, got: ${batchSize}`,\n    );\n  }\n  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {\n    throw new Error(\n      `[autotel/drain-pipeline] batch.intervalMs must be a positive finite number, got: ${intervalMs}`,\n    );\n  }\n  if (!Number.isFinite(maxBufferSize) || maxBufferSize <= 0) {\n    throw new Error(\n      `[autotel/drain-pipeline] maxBufferSize must be a positive finite number, got: ${maxBufferSize}`,\n    );\n  }\n  if (!Number.isFinite(maxAttempts) || maxAttempts <= 0) {\n    throw new Error(\n      `[autotel/drain-pipeline] retry.maxAttempts must be a positive finite number, got: ${maxAttempts}`,\n    );\n  }\n\n  return (drain: (batch: T[]) => void | Promise<void>): PipelineDrainFn<T> => {\n    const buffer: T[] = [];\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    let activeFlush: Promise<void> | null = null;\n    let isShutdown = false;\n\n    const clearTimer = () => {\n      if (timer) {\n        clearTimeout(timer);\n        timer = null;\n      }\n    };\n\n    const computeDelay = (attempt: number): number => {\n      const base =\n        backoff === 'fixed'\n          ? initialDelayMs\n          : backoff === 'linear'\n            ? initialDelayMs * attempt\n            : initialDelayMs * 2 ** (attempt - 1);\n\n      const bounded = Math.min(base, maxDelayMs);\n      if (!jitter || bounded <= 0) return bounded;\n      const factor = 0.5 + Math.random(); // [0.5, 1.5)\n      return Math.max(0, Math.round(bounded * factor));\n    };\n\n    const sendWithRetry = async (batch: T[]): Promise<void> => {\n      let lastError: Error | undefined;\n      for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n        try {\n          await drain(batch);\n          return;\n        } catch (error) {\n          lastError = error instanceof Error ? error : new Error(String(error));\n          if (attempt < maxAttempts) {\n            await wait(computeDelay(attempt));\n          }\n        }\n      }\n      onDropped?.(batch, lastError);\n    };\n\n    const drainBuffer = async (): Promise<void> => {\n      while (buffer.length > 0) {\n        const batch = buffer.splice(0, batchSize);\n        await sendWithRetry(batch);\n      }\n    };\n\n    const scheduleFlush = () => {\n      if (isShutdown || timer || activeFlush) return;\n      timer = setTimeout(() => {\n        timer = null;\n        startFlush();\n      }, intervalMs);\n      timer.unref?.();\n    };\n\n    const startFlush = () => {\n      if (activeFlush || isShutdown) return;\n      activeFlush = drainBuffer().finally(() => {\n        activeFlush = null;\n        if (isShutdown) return;\n        if (buffer.length >= batchSize) {\n          startFlush();\n        } else if (buffer.length > 0) {\n          scheduleFlush();\n        }\n      });\n    };\n\n    const push = (ctx: T) => {\n      if (isShutdown) return;\n\n      if (buffer.length >= maxBufferSize) {\n        if (dropPolicy === 'newest') {\n          onDropped?.([ctx]);\n          return;\n        }\n        const dropped = buffer.splice(0, 1);\n        onDropped?.(dropped);\n      }\n\n      buffer.push(ctx);\n      if (buffer.length >= batchSize) {\n        clearTimer();\n        startFlush();\n      } else {\n        scheduleFlush();\n      }\n    };\n\n    const flush = async (): Promise<void> => {\n      clearTimer();\n      if (activeFlush) await activeFlush;\n\n      const snapshot = buffer.length;\n      if (snapshot <= 0) return;\n      const toFlush = buffer.splice(0, snapshot);\n      while (toFlush.length > 0) {\n        const batch = toFlush.splice(0, batchSize);\n        await sendWithRetry(batch);\n      }\n    };\n\n    const shutdown = async (): Promise<void> => {\n      isShutdown = true;\n      await flush();\n    };\n\n    const fn = push as PipelineDrainFn<T>;\n    fn.flush = flush;\n    fn.shutdown = shutdown;\n    Object.defineProperty(fn, 'pending', {\n      enumerable: true,\n      get: () => buffer.length,\n    });\n    return fn;\n  };\n}\n"],"mappings":"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"}