autotel-tanstack 1.13.43 → 1.13.44

package/dist/auto.d.ts

@@ -1,8 +1,7 @@
-import { n as instrument } from "./instrument-DS7YCE1R.js";
+import { n as instrument } from "./instrument-B4bfWksz.js";
 import { functionTracingMiddleware, tracingMiddleware } from "./middleware.js";
 import { traceServerFn } from "./server-functions.js";
-import { n as traceBeforeLoad, r as traceLoader } from "./loaders-dci0y1cD.js";
-
+import { n as traceBeforeLoad, r as traceLoader } from "./loaders-DMUCHc32.js";
 //#region src/auto.d.ts
 /** Check if auto-instrumentation is active. */
 declare function isAutoInstrumentationActive(): boolean;

package/dist/auto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto.d.ts","names":[],"sources":["../src/auto.ts"],"mappings":";;;;;;;iBA+CgB,2BAAA;;iBAKA,cAAA;;iBAKA,WAAA"}
+{"version":3,"file":"auto.d.ts","names":[],"sources":["../src/auto.ts"],"mappings":";;;;;;iBA+CgB;;iBAKA;;iBAKA"}

package/dist/browser/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/browser/context.ts"],"mappings":";;AAUA;;;;AACkB;AAKlB;;;AAAA,KANY,eAAA,GACV,OAAA,GAAU,MAAM;AAKyC;AAS3D;;AAT2D,iBAA3C,yBAAA,CAA0B,QAAiB,EAAP,OAAO;;;;iBAS3C,sBAAA,CACd,OAAA,EAAS,OAAA,EACT,GAAA,aACC,OAAO;;;AAAA;iBAQM,mBAAA,CACd,eAAA,GAAkB,eAAA,EAClB,GAAA,aACC,OAAO;;;;iBAQM,YAAA,IAAgB,aAAA,WAAwB,EAAA,QAAU,CAAA,GAAI,CAAC;;;;iBAQvD,gBAAA;AAhBN;AAQV;;AARU,iBAuBM,cAAA;;;;iBAOA,aAAA;;;;iBAOA,iBAAA;AArBhB;;;AAAA,iBA4BgB,gBAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/browser/context.ts"],"mappings":";;;;;;;;;;KAUY,kBACV,UAAU;;;;iBAKI,0BAA0B,UAAU;;;;iBASpC,uBACd,SAAS,SACT,gBACC;;;;iBAQa,oBACd,kBAAkB,iBAClB,gBACC;;;;iBAQa,aAAa,GAAG,wBAAwB,UAAU,IAAI;;;;iBAQtD;;;;iBAOA;;;;iBAOA;;;;iBAOA;;;;iBAOA"}

package/dist/browser/debug-headers.d.ts

@@ -1,5 +1,4 @@
 import { MiddlewareHandler } from "./middleware.js";
-
 //#region src/browser/debug-headers.d.ts
 /**
  * Browser stub: Returns pass-through middleware

package/dist/browser/debug-headers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debug-headers.d.ts","names":[],"sources":["../../src/browser/debug-headers.ts"],"mappings":";;;;;;iBAYgB,sBAAA,wBAEX,iBAAiB,CAAC,QAAA"}
+{"version":3,"file":"debug-headers.d.ts","names":[],"sources":["../../src/browser/debug-headers.ts"],"mappings":";;;;;iBAYgB,uBACd,uBACG,kBAAkB"}

package/dist/browser/error-reporting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-reporting.d.ts","names":[],"sources":["../../src/browser/error-reporting.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,UAAA;EACf,SAAA;EACA,OAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAM;AAAA;;;;iBAMF,WAAA,CACd,KAAA,EAAO,KAAA,EACP,OAAA,GAAU,MAAM;;;AAAiB;iBAUnB,eAAA,CAAgB,KAAA,YAAiB,UAAU;;;;iBAQ3C,WAAA;AAAhB;;;AAAA,iBAOgB,2BAAA,UAAqC,QAAQ;AAPlC;AAO3B;;AAP2B,iBAiBX,kBAAA,eAAiC,IAAA,iBAC/C,EAAA,EAAI,CAAA,EACJ,OAAA,GAAU,MAAA,oBACT,CAAA"}
+{"version":3,"file":"error-reporting.d.ts","names":[],"sources":["../../src/browser/error-reporting.ts"],"mappings":";;;;;;;;;;UAUiB;EACf;EACA;EACA;EACA,UAAU;;;;;iBAMI,YACd,OAAO,OACP,UAAU;;;;iBAUI,gBAAgB,iBAAiB;;;;iBAQjC;;;;iBAOA,qCAAqC;;;;iBAUrC,mBAAmB,cAAc,qBAC/C,IAAI,GACJ,UAAU,0BACT"}

package/dist/browser/handlers.d.ts

@@ -1,5 +1,4 @@
 import { c as WrapStartHandlerConfig } from "../types-BJ7FyVoX.js";
-
 //#region src/browser/handlers.d.ts
 /**
  * Handler type

package/dist/browser/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","names":[],"sources":["../../src/browser/handlers.ts"],"mappings":";;;;;;KAYY,YAAA,iBAA6B,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,CAAA;;;;iBAKtD,gBAAA,IACd,MAAA,GAAS,sBAAA,IACP,OAAA,EAAS,YAAA,CAAa,CAAA,MAAO,YAAA,CAAa,CAAA"}
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../../src/browser/handlers.ts"],"mappings":";;;;;KAYY,aAAa,gBAAgB,SAAS,YAAY,QAAQ;;;;iBAKtD,iBAAiB,GAC/B,SAAS,0BACP,SAAS,aAAa,OAAO,aAAa"}

package/dist/browser/loaders.d.ts

@@ -1,5 +1,4 @@
 import { a as TraceLoaderConfig } from "../types-BJ7FyVoX.js";
-
 //#region src/browser/loaders.d.ts
 /**
  * Loader context type (compatible with TanStack router loader context)

package/dist/browser/loaders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loaders.d.ts","names":[],"sources":["../../src/browser/loaders.ts"],"mappings":";;;;;;UAYU,aAAA;EACR,MAAA,GAAS,MAAM;EACf,KAAA;IACE,EAAA;EAAA;EAAA,CAED,GAAA;AAAA;;;;iBAMa,WAAA,YACH,OAAA,EAAS,aAAA,KAAkB,OAAA,WACtC,QAAA,EAAU,CAAA,EAAG,MAAA,GAAS,iBAAA,GAAoB,CAAA;;;;iBAQ5B,eAAA,YACH,OAAA,EAAS,aAAA,KAAkB,OAAA,WACtC,YAAA,EAAc,CAAA,EAAG,MAAA,GAAS,iBAAA,GAAoB,CAAA;;;;iBAQhC,iBAAA,CACd,OAAA,UACA,MAAA,GAAS,IAAA,CAAK,iBAAA;oBAKM,OAAA,EAAS,aAAA,KAAkB,OAAA,WAAgB,QAAA,EACjD,CAAA,GACT,CAAA;wBAGmB,OAAA,EAAS,aAAA,KAAkB,OAAA,WAAgB,YAAA,EACjD,CAAA,GACb,CAAA;AAAA"}
+{"version":3,"file":"loaders.d.ts","names":[],"sources":["../../src/browser/loaders.ts"],"mappings":";;;;;UAYU;EACR,SAAS;EACT;IACE;;GAED;;;;;iBAMa,YACd,WAAW,SAAS,kBAAkB,kBACtC,UAAU,GAAG,SAAS,oBAAoB;;;;iBAQ5B,gBACd,WAAW,SAAS,kBAAkB,kBACtC,cAAc,GAAG,SAAS,oBAAoB;;;;iBAQhC,kBACd,iBACA,SAAS,KAAK;EAKL,OAAA,WAAW,SAAS,kBAAkB,kBAAgB,UACjD,IACT;EAGQ,WAAA,WAAW,SAAS,kBAAkB,kBAAgB,cACjD,IACb"}

package/dist/browser/metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.d.ts","names":[],"sources":["../../src/browser/metrics.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,WAAA;EACf,YAAA;EACA,UAAA;EACA,UAAA;EACA,UAAA;EACA,UAAA;EACA,UAAA;EACA,iBAAA;EACA,SAAA,EAAW,MAAM;IAGb,KAAA;IACA,MAAA;IACA,UAAA;EAAA;AAAA;AAQmC;AAgBzC;;AAhByC,iBAAzB,UAAA,IAAc,WAAW;;AAgBoB;AAS7D;iBATgB,YAAA,CAAa,IAAA,UAAc,UAAkB;;;AASrB;iBAAxB,WAAA,CAAY,IAAY;;;;iBAQxB,YAAA;AAOhB;;;AAAA,cAAa,gBAAA;;;;;;;;;iBAUG,oBAAA,UAA8B,QAAQ"}
+{"version":3,"file":"metrics.d.ts","names":[],"sources":["../../src/browser/metrics.ts"],"mappings":";;;;;;;;;;UAUiB;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;IAGP;IACA;IACA;;;;;;iBAQU,cAAc;;;;iBAgBd,aAAa,cAAc;;;;iBAS3B,YAAY;;;;iBAQZ;;;;cAOH;;;;;;;;;iBAUG,8BAA8B"}

package/dist/browser/middleware.d.ts

@@ -1,5 +1,4 @@
 import { s as TracingMiddlewareConfig } from "../types-BJ7FyVoX.js";
-
 //#region src/browser/middleware.d.ts
 /**
  * Generic middleware handler type

package/dist/browser/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/browser/middleware.ts"],"mappings":";;;;;;UAYiB,iBAAA;EAAA,CACd,IAAA;IACC,IAAA,GAAO,GAAA,GAAM,OAAA,CAAQ,QAAA,MAAc,OAAA,CAAQ,QAAA;IAC3C,OAAA,EAAS,QAAA;IACT,OAAA,GAAU,OAAA;IACV,QAAA;IACA,IAAA;IACA,MAAA;IACA,QAAA;IACA,UAAA;IACA,MAAA,GAAS,WAAA;EAAA,IACP,OAAA,CAAQ,QAAA;AAAA;;;;iBAME,uBAAA,qBACd,MAAA,GAAS,uBAAA,GACR,iBAAA,CAAkB,QAAA;;;;iBAUL,iBAAA,qBACd,MAAA,GAAS,uBAAA,GACR,iBAAA,CAAkB,QAAA;;;;iBAUL,yBAAA,qBACd,MAAA,GAAS,IAAA,CAAK,uBAAA,YACb,iBAAA,CAAkB,QAAA;;;;iBAUL,0BAAA,qBACd,MAAA,GAAS,uBAAA,IACP,IAAA;EACF,IAAA,GAAO,GAAA,GAAM,OAAA,CAAQ,QAAA,MAAc,OAAA,CAAQ,QAAA;EAC3C,OAAA,EAAS,QAAA;EACT,OAAA,GAAU,OAAA;AAAA,MACN,OAAA,CAAQ,QAAA"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/browser/middleware.ts"],"mappings":";;;;;UAYiB,kBAAkB;GAChC;IACC,OAAO,MAAM,QAAQ,cAAc,QAAQ;IAC3C,SAAS;IACT,UAAU;IACV;IACA;IACA;IACA;IACA;IACA,SAAS;MACP,QAAQ;;;;;iBAME,wBAAwB,oBACtC,SAAS,0BACR,kBAAkB;;;;iBAUL,kBAAkB,oBAChC,SAAS,0BACR,kBAAkB;;;;iBAUL,0BAA0B,oBACxC,SAAS,KAAK,mCACb,kBAAkB;;;;iBAUL,2BAA2B,oBACzC,SAAS,2BACP;EACF,OAAO,MAAM,QAAQ,cAAc,QAAQ;EAC3C,SAAS;EACT,UAAU;MACN,QAAQ"}

package/dist/browser/server-functions.d.ts

@@ -1,5 +1,4 @@
 import { o as TraceServerFnConfig } from "../types-BJ7FyVoX.js";
-
 //#region src/browser/server-functions.d.ts
 /**
  * Browser stub: Returns the server function unchanged

package/dist/browser/server-functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-functions.d.ts","names":[],"sources":["../../src/browser/server-functions.ts"],"mappings":";;;;;;iBAYgB,aAAA,eACA,IAAA,gBAAoB,OAAA,WAClC,QAAA,EAAU,CAAA,EAAG,MAAA,GAAS,mBAAA,GAAsB,CAAA;;;;iBAQ9B,2BAAA,6BACc,IAAA,yBAE5B,sBAAA,EAAwB,eAAA,EACxB,aAAA,GAAgB,IAAA,CAAK,mBAAA,YACpB,eAAA"}
+{"version":3,"file":"server-functions.d.ts","names":[],"sources":["../../src/browser/server-functions.ts"],"mappings":";;;;;iBAYgB,cACd,cAAc,oBAAoB,kBAClC,UAAU,GAAG,SAAS,sBAAsB;;;;iBAQ9B,4BACd,4BAA4B,6BAE5B,wBAAwB,iBACxB,gBAAgB,KAAK,+BACpB"}

package/dist/browser/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","names":[],"sources":["../../src/browser/testing.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,QAAA;EACf,IAAA;EACA,UAAA,EAAY,MAAA;EACZ,MAAA;IAAU,IAAA;IAAc,OAAA;EAAA;EACxB,MAAA,EAAQ,KAAA;IAAQ,IAAA;IAAc,UAAA,GAAa,MAAA;EAAA;EAC3C,QAAA;AAAA;AAAQ;AAMV;;AANU,UAMO,aAAA;EACf,QAAA,IAAY,QAAA;EACZ,cAAA,CAAe,IAAA,WAAe,QAAA;EAC9B,KAAA;EACA,YAAA,CAAa,KAAA,UAAe,OAAA,YAAmB,OAAA,CAAQ,QAAA;AAAA;;;;iBAMzC,mBAAA,IAAuB,aAAa;;;;iBAYpC,iBAAA,CACd,SAAA,EAAW,aAAa,EACxB,IAAA;;;;iBAUc,sBAAA,CACd,SAAA,EAAW,aAAa,EACxB,IAAA,UACA,GAAA,UACA,KAAA;;AAlC+D;AAMjE;;;;KA2CY,cAAA;EACV,IAAA;EACA,MAAA;EACA,OAAA;EACA,YAAA;EACA,UAAA,GAAa,MAAM;EACnB,MAAA;IAAU,IAAA;IAAc,OAAA;EAAA;EACxB,UAAA;AAAA;;;;;KAOG,YAAA,GAAe,OAAA;EAAY,OAAA,EAAS,OAAO;AAAA;AAAA,KAG3C,eAAA,IAAmB,IAAA,cAAkB,OAAY;AAhCrC;AAejB;;AAfiB,iBAqCD,oBAAA,CACd,eAAA,EAAiB,eAAe,EAChC,IAAA;;;;;iBAWc,uBAAA;EACd,GAAA,GAAM,KAAA,EAAO,YAAA,KAAiB,QAAA;EAC9B,MAAA,GAAS,KAAA,EAAO,YAAA,KAAiB,QAAA;AAAA"}
+{"version":3,"file":"testing.d.ts","names":[],"sources":["../../src/browser/testing.ts"],"mappings":";;;;;;;;;;UAUiB;EACf;EACA,YAAY;EACZ;IAAU;IAAc;;EACxB,QAAQ;IAAQ;IAAc,aAAa;;EAC3C;;;;;UAMe;EACf,YAAY;EACZ,eAAe,eAAe;EAC9B;EACA,aAAa,eAAe,mBAAmB,QAAQ;;;;;iBAMzC,uBAAuB;;;;iBAYvB,kBACd,WAAW,eACX;;;;iBAUc,uBACd,WAAW,eACX,cACA,aACA;;;;;;;KAeU;EACV;EACA;EACA;EACA;EACA,aAAa;EACb;IAAU;IAAc;;EACxB;;;;;;KAOG,eAAe;EAAY,SAAS;;KAGpC,mBAAmB,kBAAkB;;;;iBAK1B,qBACd,iBAAiB,iBACjB;;;;;iBAWc;EACd,MAAM,OAAO,iBAAiB;EAC9B,SAAS,OAAO,iBAAiB"}

package/dist/context.d.ts

@@ -1,5 +1,4 @@
 import { Context } from "@opentelemetry/api";
-
 //#region src/context.d.ts
 /**
  * Type representing values that can be used to initialize Headers
@@ -20,7 +19,8 @@ type HeadersInitType = Headers | Record<string, string> | [string, string][];
  * const parentContext = extractContextFromRequest(request);
  * context.with(parentContext, async () => {
  *   // Spans created here will be children of the extracted context
- *   await trace('my-operation', async (ctx) => { ... });
+ *   await trace('my-operation', async ()=> {
+      const ctx = getActiveTraceContext()!; ... })();
  * });
  * ```
  */

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;AAWA;;KAAY,eAAA,GACV,OAAA,GAAU,MAAM;;AAAA;AAoBlB;;;;;;;;AAAoE;AAuCpE;;;;;;;iBAvCgB,yBAAA,CAA0B,OAAA,EAAS,OAAA,GAAU,OAAO;;;;;;;AA0C1D;AA+BV;;;;;;;;;;;;iBAlCgB,sBAAA,CACd,OAAA,EAAS,OAAA,EACT,GAAA,GAAM,OAAA,GACL,OAAA;;AAkCO;AAuBV;;;;;;;;;;;;;;;AAAuE;AASvE;;iBAnCgB,mBAAA,CACd,eAAA,GAAkB,eAAA,EAClB,GAAA,GAAM,OAAA,GACL,OAAA;;AAgCwC;;;;;;;;;;;;;;;;;iBAT3B,YAAA,IAAgB,aAAA,EAAe,OAAA,EAAS,EAAA,QAAU,CAAA,GAAI,CAAA;;;;;;iBAStD,gBAAA,IAAoB,OAAO"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;KAWY,kBACV,UAAU;;;;;;;;;;;;;;;;;;;;iBAqBI,0BAA0B,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;iBAuC7C,uBACd,SAAS,SACT,MAAM,UACL;;;;;;;;;;;;;;;;;;;;;iBA+Ba,oBACd,kBAAkB,iBAClB,MAAM,UACL;;;;;;;;;;;;;;;;;;;iBAuBa,aAAa,GAAG,eAAe,SAAS,UAAU,IAAI;;;;;;iBAStD,oBAAoB"}

package/dist/context.js

@@ -15,7 +15,8 @@ import { ROOT_CONTEXT, context, propagation } from "@opentelemetry/api";
 * const parentContext = extractContextFromRequest(request);
 * context.with(parentContext, async () => {
 *   // Spans created here will be children of the extracted context
-*   await trace('my-operation', async (ctx) => { ... });
+*   await trace('my-operation', async ()=> {
+const ctx = getActiveTraceContext()!; ... })();
 * });
 * ```
 */

package/dist/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import {\n  context,\n  propagation,\n  type Context,\n  ROOT_CONTEXT,\n} from '@opentelemetry/api';\n\n/**\n * Type representing values that can be used to initialize Headers\n * This is equivalent to the DOM's HeadersInit type but works in Node.js\n */\nexport type HeadersInitType =\n  Headers | Record<string, string> | [string, string][];\n\n/**\n * Extract OpenTelemetry context from HTTP request headers\n *\n * This function extracts W3C Trace Context (traceparent, tracestate)\n * and Baggage from request headers to enable distributed tracing.\n *\n * @param request - The incoming HTTP request\n * @returns OpenTelemetry context with extracted trace information\n *\n * @example\n * ```typescript\n * const parentContext = extractContextFromRequest(request);\n * context.with(parentContext, async () => {\n *   // Spans created here will be children of the extracted context\n *   await trace('my-operation', async (ctx) => { ... });\n * });\n * ```\n */\nexport function extractContextFromRequest(request: Request): Context {\n  const carrier: Record<string, string> = {};\n\n  // Extract W3C Trace Context headers\n  const traceparent = request.headers.get('traceparent');\n  const tracestate = request.headers.get('tracestate');\n  const baggage = request.headers.get('baggage');\n\n  if (traceparent) carrier.traceparent = traceparent;\n  if (tracestate) carrier.tracestate = tracestate;\n  if (baggage) carrier.baggage = baggage;\n\n  // Return ROOT_CONTEXT if no trace headers present\n  if (Object.keys(carrier).length === 0) {\n    return ROOT_CONTEXT;\n  }\n\n  return propagation.extract(context.active(), carrier);\n}\n\n/**\n * Inject OpenTelemetry context into HTTP headers\n *\n * This function injects W3C Trace Context (traceparent, tracestate)\n * and Baggage into headers for outgoing requests.\n *\n * @param headers - Headers object to inject context into\n * @param ctx - Optional context to inject (defaults to active context)\n * @returns The headers object with injected trace context\n *\n * @example\n * ```typescript\n * const headers = new Headers();\n * injectContextToHeaders(headers);\n *\n * // Now use headers in outgoing fetch\n * await fetch('https://api.example.com', { headers });\n * ```\n */\nexport function injectContextToHeaders(\n  headers: Headers,\n  ctx?: Context,\n): Headers {\n  const carrier: Record<string, string> = {};\n  propagation.inject(ctx ?? context.active(), carrier);\n\n  for (const [key, value] of Object.entries(carrier)) {\n    headers.set(key, value);\n  }\n\n  return headers;\n}\n\n/**\n * Create a new Headers object with injected trace context\n *\n * Convenience function that creates a new Headers object\n * with the current trace context already injected.\n *\n * @param existingHeaders - Optional existing headers to include\n * @param ctx - Optional context to inject (defaults to active context)\n * @returns New Headers object with trace context\n *\n * @example\n * ```typescript\n * const headers = createTracedHeaders({ 'Content-Type': 'application/json' });\n * await fetch('https://api.example.com', {\n *   method: 'POST',\n *   headers,\n *   body: JSON.stringify(data),\n * });\n * ```\n */\nexport function createTracedHeaders(\n  existingHeaders?: HeadersInitType,\n  ctx?: Context,\n): Headers {\n  const headers = new Headers(existingHeaders);\n  return injectContextToHeaders(headers, ctx);\n}\n\n/**\n * Run a function within a specific OpenTelemetry context\n *\n * This is a convenience wrapper around context.with() that\n * provides better TypeScript inference.\n *\n * @param parentContext - The context to run within\n * @param fn - The function to execute\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * const parentContext = extractContextFromRequest(request);\n * const result = await runInContext(parentContext, async () => {\n *   return await processRequest();\n * });\n * ```\n */\nexport function runInContext<T>(parentContext: Context, fn: () => T): T {\n  return context.with(parentContext, fn);\n}\n\n/**\n * Get the current active context\n *\n * @returns The current active OpenTelemetry context\n */\nexport function getActiveContext(): Context {\n  return context.active();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,0BAA0B,SAA2B;CACnE,MAAM,UAAkC,CAAC;CAGzC,MAAM,cAAc,QAAQ,QAAQ,IAAI,aAAa;CACrD,MAAM,aAAa,QAAQ,QAAQ,IAAI,YAAY;CACnD,MAAM,UAAU,QAAQ,QAAQ,IAAI,SAAS;CAE7C,IAAI,aAAa,QAAQ,cAAc;CACvC,IAAI,YAAY,QAAQ,aAAa;CACrC,IAAI,SAAS,QAAQ,UAAU;CAG/B,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,OAAO;CAGT,OAAO,YAAY,QAAQ,QAAQ,OAAO,GAAG,OAAO;AACtD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBACd,SACA,KACS;CACT,MAAM,UAAkC,CAAC;CACzC,YAAY,OAAO,OAAO,QAAQ,OAAO,GAAG,OAAO;CAEnD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAC/C,QAAQ,IAAI,KAAK,KAAK;CAGxB,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,oBACd,iBACA,KACS;CAET,OAAO,uBAAuB,IADV,QAAQ,eACQ,GAAG,GAAG;AAC5C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAgB,eAAwB,IAAgB;CACtE,OAAO,QAAQ,KAAK,eAAe,EAAE;AACvC;;;;;;AAOA,SAAgB,mBAA4B;CAC1C,OAAO,QAAQ,OAAO;AACxB"}
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import {\n  context,\n  propagation,\n  type Context,\n  ROOT_CONTEXT,\n} from '@opentelemetry/api';\n\n/**\n * Type representing values that can be used to initialize Headers\n * This is equivalent to the DOM's HeadersInit type but works in Node.js\n */\nexport type HeadersInitType =\n  Headers | Record<string, string> | [string, string][];\n\n/**\n * Extract OpenTelemetry context from HTTP request headers\n *\n * This function extracts W3C Trace Context (traceparent, tracestate)\n * and Baggage from request headers to enable distributed tracing.\n *\n * @param request - The incoming HTTP request\n * @returns OpenTelemetry context with extracted trace information\n *\n * @example\n * ```typescript\n * const parentContext = extractContextFromRequest(request);\n * context.with(parentContext, async () => {\n *   // Spans created here will be children of the extracted context\n *   await trace('my-operation', async ()=> {\n      const ctx = getActiveTraceContext()!; ... })();\n * });\n * ```\n */\nexport function extractContextFromRequest(request: Request): Context {\n  const carrier: Record<string, string> = {};\n\n  // Extract W3C Trace Context headers\n  const traceparent = request.headers.get('traceparent');\n  const tracestate = request.headers.get('tracestate');\n  const baggage = request.headers.get('baggage');\n\n  if (traceparent) carrier.traceparent = traceparent;\n  if (tracestate) carrier.tracestate = tracestate;\n  if (baggage) carrier.baggage = baggage;\n\n  // Return ROOT_CONTEXT if no trace headers present\n  if (Object.keys(carrier).length === 0) {\n    return ROOT_CONTEXT;\n  }\n\n  return propagation.extract(context.active(), carrier);\n}\n\n/**\n * Inject OpenTelemetry context into HTTP headers\n *\n * This function injects W3C Trace Context (traceparent, tracestate)\n * and Baggage into headers for outgoing requests.\n *\n * @param headers - Headers object to inject context into\n * @param ctx - Optional context to inject (defaults to active context)\n * @returns The headers object with injected trace context\n *\n * @example\n * ```typescript\n * const headers = new Headers();\n * injectContextToHeaders(headers);\n *\n * // Now use headers in outgoing fetch\n * await fetch('https://api.example.com', { headers });\n * ```\n */\nexport function injectContextToHeaders(\n  headers: Headers,\n  ctx?: Context,\n): Headers {\n  const carrier: Record<string, string> = {};\n  propagation.inject(ctx ?? context.active(), carrier);\n\n  for (const [key, value] of Object.entries(carrier)) {\n    headers.set(key, value);\n  }\n\n  return headers;\n}\n\n/**\n * Create a new Headers object with injected trace context\n *\n * Convenience function that creates a new Headers object\n * with the current trace context already injected.\n *\n * @param existingHeaders - Optional existing headers to include\n * @param ctx - Optional context to inject (defaults to active context)\n * @returns New Headers object with trace context\n *\n * @example\n * ```typescript\n * const headers = createTracedHeaders({ 'Content-Type': 'application/json' });\n * await fetch('https://api.example.com', {\n *   method: 'POST',\n *   headers,\n *   body: JSON.stringify(data),\n * });\n * ```\n */\nexport function createTracedHeaders(\n  existingHeaders?: HeadersInitType,\n  ctx?: Context,\n): Headers {\n  const headers = new Headers(existingHeaders);\n  return injectContextToHeaders(headers, ctx);\n}\n\n/**\n * Run a function within a specific OpenTelemetry context\n *\n * This is a convenience wrapper around context.with() that\n * provides better TypeScript inference.\n *\n * @param parentContext - The context to run within\n * @param fn - The function to execute\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * const parentContext = extractContextFromRequest(request);\n * const result = await runInContext(parentContext, async () => {\n *   return await processRequest();\n * });\n * ```\n */\nexport function runInContext<T>(parentContext: Context, fn: () => T): T {\n  return context.with(parentContext, fn);\n}\n\n/**\n * Get the current active context\n *\n * @returns The current active OpenTelemetry context\n */\nexport function getActiveContext(): Context {\n  return context.active();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,0BAA0B,SAA2B;CACnE,MAAM,UAAkC,CAAC;CAGzC,MAAM,cAAc,QAAQ,QAAQ,IAAI,aAAa;CACrD,MAAM,aAAa,QAAQ,QAAQ,IAAI,YAAY;CACnD,MAAM,UAAU,QAAQ,QAAQ,IAAI,SAAS;CAE7C,IAAI,aAAa,QAAQ,cAAc;CACvC,IAAI,YAAY,QAAQ,aAAa;CACrC,IAAI,SAAS,QAAQ,UAAU;CAG/B,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,OAAO;CAGT,OAAO,YAAY,QAAQ,QAAQ,OAAO,GAAG,OAAO;AACtD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBACd,SACA,KACS;CACT,MAAM,UAAkC,CAAC;CACzC,YAAY,OAAO,OAAO,QAAQ,OAAO,GAAG,OAAO;CAEnD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAC/C,QAAQ,IAAI,KAAK,KAAK;CAGxB,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,oBACd,iBACA,KACS;CAET,OAAO,uBAAuB,IADV,QAAQ,eACQ,GAAG,GAAG;AAC5C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAgB,eAAwB,IAAgB;CACtE,OAAO,QAAQ,KAAK,eAAe,EAAE;AACvC;;;;;;AAOA,SAAgB,mBAA4B;CAC1C,OAAO,QAAQ,OAAO;AACxB"}

package/dist/control-flow-p-dnko0G.js

@@ -0,0 +1,78 @@
+//#region src/types.ts
+/**
+* Default configuration values
+*/
+const DEFAULT_CONFIG = {
+	captureArgs: true,
+	captureResults: false,
+	captureErrors: true,
+	captureHeaders: ["x-request-id"],
+	excludePaths: [],
+	sampling: "adaptive"
+};
+/**
+* Span attribute keys following OpenTelemetry semantic conventions
+*/
+const SPAN_ATTRIBUTES = {
+	HTTP_REQUEST_METHOD: "http.request.method",
+	HTTP_RESPONSE_STATUS_CODE: "http.response.status_code",
+	URL_PATH: "url.path",
+	URL_QUERY: "url.query",
+	URL_FULL: "url.full",
+	RPC_SYSTEM: "rpc.system",
+	RPC_METHOD: "rpc.method",
+	TANSTACK_TYPE: "tanstack.type",
+	TANSTACK_SERVER_FN_NAME: "tanstack.server_function.name",
+	TANSTACK_SERVER_FN_METHOD: "tanstack.server_function.method",
+	TANSTACK_SERVER_FN_ARGS: "tanstack.server_function.args",
+	TANSTACK_SERVER_FN_RESULT: "tanstack.server_function.result",
+	TANSTACK_LOADER_ROUTE_ID: "tanstack.loader.route_id",
+	TANSTACK_LOADER_TYPE: "tanstack.loader.type",
+	TANSTACK_LOADER_PARAMS: "tanstack.loader.params",
+	TANSTACK_MIDDLEWARE_NAME: "tanstack.middleware.name",
+	TANSTACK_REQUEST_DURATION_MS: "tanstack.request.duration_ms"
+};
+
+//#endregion
+//#region src/control-flow.ts
+/**
+* TanStack Router control-flow signal detection.
+*
+* `redirect()` and `notFound()` are throw-based navigation signals: the
+* framework catches them and turns them into a real response. They are not
+* application errors, so instrumentation must not record them on a span or
+* report them to the error store.
+*
+* We match TanStack's own public predicate shapes rather than importing
+* `isRedirect`/`isNotFound`, so the check works for both React Start and Solid
+* Start without a hard dependency on a specific `@tanstack` package:
+*
+*   - `redirect()` throws a `Response` carrying an `.options` bag
+*     (`@tanstack/router-core` `isRedirect`).
+*   - `notFound()` throws a plain object with `isNotFound === true`
+*     (`@tanstack/router-core` `isNotFound`).
+*
+* The `name`-based branch keeps older TanStack versions covered, which threw
+* `RedirectError` / `NotFoundError` instances instead.
+*/
+function isControlFlowSignal(error) {
+	if (typeof Response !== "undefined" && error instanceof Response && error.options != null) return true;
+	if (typeof error === "object" && error !== null) {
+		if (error.isNotFound === true) return true;
+		const name = error.name;
+		if (name === "RedirectError" || name === "NotFoundError") return true;
+	}
+	return false;
+}
+/**
+* Negation of {@link isControlFlowSignal}, shaped for autotel `trace()`'s
+* `isError` option: returns `false` for control-flow signals so the span is
+* marked OK and no exception is recorded, `true` for real errors.
+*/
+function isRealError(error) {
+	return !isControlFlowSignal(error);
+}
+
+//#endregion
+export { SPAN_ATTRIBUTES as i, isRealError as n, DEFAULT_CONFIG as r, isControlFlowSignal as t };
+//# sourceMappingURL=control-flow-p-dnko0G.js.map

package/dist/control-flow-p-dnko0G.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-flow-p-dnko0G.js","names":[],"sources":["../src/types.ts","../src/control-flow.ts"],"sourcesContent":["import type { Attributes } from '@opentelemetry/api';\n\n/**\n * Configuration options for TanStack Start instrumentation\n */\nexport interface TanStackInstrumentationConfig {\n  /**\n   * Service name for spans\n   * @default process.env.OTEL_SERVICE_NAME || 'tanstack-start'\n   */\n  service?: string;\n\n  /**\n   * Whether to capture function arguments as span attributes\n   * Warning: May contain PII, review before enabling in production\n   * @default true\n   */\n  captureArgs?: boolean;\n\n  /**\n   * Whether to capture function results as span attributes\n   * Warning: May contain PII, disable in production\n   * @default false\n   */\n  captureResults?: boolean;\n\n  /**\n   * Whether to capture errors and record exceptions\n   * @default true\n   */\n  captureErrors?: boolean;\n\n  /**\n   * HTTP headers to capture as span attributes\n   * @default ['x-request-id']\n   */\n  captureHeaders?: string[];\n\n  /**\n   * URL paths to exclude from tracing (glob patterns)\n   * @default []\n   */\n  excludePaths?: (string | RegExp)[];\n\n  /**\n   * Sampling strategy\n   * - 'always': Sample all requests (100%)\n   * - 'adaptive': Use autotel's adaptive sampling (errors + slow = 100%, baseline 10%)\n   * - 'never': Disable sampling (for testing/debugging)\n   * @default 'adaptive'\n   */\n  sampling?: 'always' | 'adaptive' | 'never';\n\n  /**\n   * Custom function to extract additional span attributes\n   */\n  customAttributes?: (context: {\n    type: 'request' | 'serverFn' | 'loader' | 'beforeLoad' | 'middleware';\n    name: string;\n    request?: Request;\n    args?: unknown;\n    result?: unknown;\n  }) => Attributes;\n}\n\n/**\n * Configuration specific to tracing middleware\n */\nexport interface TracingMiddlewareConfig extends TanStackInstrumentationConfig {\n  /**\n   * Type of middleware\n   * - 'request': For global request middleware (routes, SSR)\n   * - 'function': For server function middleware\n   * @default 'request'\n   */\n  type?: 'request' | 'function';\n}\n\n/**\n * Configuration for server function tracing\n */\nexport interface TraceServerFnConfig {\n  /**\n   * Explicit name for the span\n   * If not provided, will attempt to infer from function name\n   */\n  name?: string;\n\n  /**\n   * Whether to capture function arguments\n   * @default true\n   */\n  captureArgs?: boolean;\n\n  /**\n   * Whether to capture function results\n   * @default false\n   */\n  captureResults?: boolean;\n}\n\n/**\n * Configuration for loader tracing\n */\nexport interface TraceLoaderConfig {\n  /**\n   * Explicit name for the span\n   * If not provided, will use route ID\n   */\n  name?: string;\n\n  /**\n   * Whether to capture route params\n   * @default true\n   */\n  captureParams?: boolean;\n\n  /**\n   * Whether to capture loader result\n   * @default false\n   */\n  captureResult?: boolean;\n}\n\n/**\n * Configuration for handler wrapper\n */\nexport interface WrapStartHandlerConfig extends TanStackInstrumentationConfig {\n  /**\n   * OTLP endpoint URL\n   * @default process.env.OTEL_EXPORTER_OTLP_ENDPOINT\n   */\n  endpoint?: string;\n\n  /**\n   * OTLP headers (e.g., for authentication)\n   * @default parsed from process.env.OTEL_EXPORTER_OTLP_HEADERS\n   */\n  headers?: Record<string, string>;\n}\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: Required<\n  Omit<TanStackInstrumentationConfig, 'customAttributes' | 'service'>\n> = {\n  captureArgs: true,\n  captureResults: false,\n  captureErrors: true,\n  captureHeaders: ['x-request-id'],\n  excludePaths: [],\n  sampling: 'adaptive',\n};\n\n/**\n * Span attribute keys following OpenTelemetry semantic conventions\n */\nexport const SPAN_ATTRIBUTES = {\n  // HTTP semantic conventions\n  HTTP_REQUEST_METHOD: 'http.request.method',\n  HTTP_RESPONSE_STATUS_CODE: 'http.response.status_code',\n  URL_PATH: 'url.path',\n  URL_QUERY: 'url.query',\n  URL_FULL: 'url.full',\n\n  // RPC semantic conventions (for server functions)\n  RPC_SYSTEM: 'rpc.system',\n  RPC_METHOD: 'rpc.method',\n\n  // TanStack-specific attributes\n  TANSTACK_TYPE: 'tanstack.type',\n  TANSTACK_SERVER_FN_NAME: 'tanstack.server_function.name',\n  TANSTACK_SERVER_FN_METHOD: 'tanstack.server_function.method',\n  TANSTACK_SERVER_FN_ARGS: 'tanstack.server_function.args',\n  TANSTACK_SERVER_FN_RESULT: 'tanstack.server_function.result',\n  TANSTACK_LOADER_ROUTE_ID: 'tanstack.loader.route_id',\n  TANSTACK_LOADER_TYPE: 'tanstack.loader.type',\n  TANSTACK_LOADER_PARAMS: 'tanstack.loader.params',\n  TANSTACK_MIDDLEWARE_NAME: 'tanstack.middleware.name',\n  TANSTACK_REQUEST_DURATION_MS: 'tanstack.request.duration_ms',\n} as const;\n","/**\n * TanStack Router control-flow signal detection.\n *\n * `redirect()` and `notFound()` are throw-based navigation signals: the\n * framework catches them and turns them into a real response. They are not\n * application errors, so instrumentation must not record them on a span or\n * report them to the error store.\n *\n * We match TanStack's own public predicate shapes rather than importing\n * `isRedirect`/`isNotFound`, so the check works for both React Start and Solid\n * Start without a hard dependency on a specific `@tanstack` package:\n *\n *   - `redirect()` throws a `Response` carrying an `.options` bag\n *     (`@tanstack/router-core` `isRedirect`).\n *   - `notFound()` throws a plain object with `isNotFound === true`\n *     (`@tanstack/router-core` `isNotFound`).\n *\n * The `name`-based branch keeps older TanStack versions covered, which threw\n * `RedirectError` / `NotFoundError` instances instead.\n */\nexport function isControlFlowSignal(error: unknown): boolean {\n  if (\n    typeof Response !== 'undefined' &&\n    error instanceof Response &&\n    (error as { options?: unknown }).options != null\n  ) {\n    return true;\n  }\n\n  if (typeof error === 'object' && error !== null) {\n    if ((error as { isNotFound?: unknown }).isNotFound === true) {\n      return true;\n    }\n    const name = (error as { name?: unknown }).name;\n    if (name === 'RedirectError' || name === 'NotFoundError') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Negation of {@link isControlFlowSignal}, shaped for autotel `trace()`'s\n * `isError` option: returns `false` for control-flow signals so the span is\n * marked OK and no exception is recorded, `true` for real errors.\n */\nexport function isRealError(error: unknown): boolean {\n  return !isControlFlowSignal(error);\n}\n"],"mappings":";;;;AAgJA,MAAa,iBAET;CACF,aAAa;CACb,gBAAgB;CAChB,eAAe;CACf,gBAAgB,CAAC,cAAc;CAC/B,cAAc,CAAC;CACf,UAAU;AACZ;;;;AAKA,MAAa,kBAAkB;CAE7B,qBAAqB;CACrB,2BAA2B;CAC3B,UAAU;CACV,WAAW;CACX,UAAU;CAGV,YAAY;CACZ,YAAY;CAGZ,eAAe;CACf,yBAAyB;CACzB,2BAA2B;CAC3B,yBAAyB;CACzB,2BAA2B;CAC3B,0BAA0B;CAC1B,sBAAsB;CACtB,wBAAwB;CACxB,0BAA0B;CAC1B,8BAA8B;AAChC;;;;;;;;;;;;;;;;;;;;;;;;ACjKA,SAAgB,oBAAoB,OAAyB;CAC3D,IACE,OAAO,aAAa,eACpB,iBAAiB,YAChB,MAAgC,WAAW,MAE5C,OAAO;CAGT,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM;EAC/C,IAAK,MAAmC,eAAe,MACrD,OAAO;EAET,MAAM,OAAQ,MAA6B;EAC3C,IAAI,SAAS,mBAAmB,SAAS,iBACvC,OAAO;CAEX;CAEA,OAAO;AACT;;;;;;AAOA,SAAgB,YAAY,OAAyB;CACnD,OAAO,CAAC,oBAAoB,KAAK;AACnC"}

package/dist/debug-headers.d.ts

@@ -1,5 +1,4 @@
 import { MiddlewareHandler } from "./middleware.js";
-
 //#region src/debug-headers.d.ts
 /**
  * Configuration for debug headers middleware

package/dist/debug-headers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debug-headers.d.ts","names":[],"sources":["../src/debug-headers.ts"],"mappings":";;;;;AAMA;UAAiB,kBAAA;;;;;EAKf,OAAA;EAKsB;AAAA;AAyBxB;EAzBE,aAAA,GAAgB,MAAM;AAAA;;;;;;AA2BJ;;;;;;;;;;;;;;;;;iBAFJ,sBAAA,CACd,MAAA,GAAQ,kBAAA,GACP,iBAAiB"}
+{"version":3,"file":"debug-headers.d.ts","names":[],"sources":["../src/debug-headers.ts"],"mappings":";;;;;UAMiB;;;;;EAKf;;;;EAKA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;iBAyBF,uBACd,SAAQ,qBACP"}

package/dist/error-reporting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-reporting.d.ts","names":[],"sources":["../src/error-reporting.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,WAAA;EACf,EAAA;EACA,KAAA;EACA,QAAA,EAAU,IAAI;EACd,KAAA;IACE,IAAA;IACA,OAAA;IACA,KAAA;IACA,OAAA;EAAA;AAAA;;;;;;;cAUE,UAAA;EAAA,QACI,MAAA;EAAA,iBACS,SAAA;EAKS;;;EAA1B,WAAA,CAAY,KAAA,EAAO,KAAA,EAAO,OAAA;EA+DjB;;;EAPT,YAAA,IAAgB,WAAA;EAqBL;;AAAU;EAdrB,QAAA,CAAS,EAAA,WAAa,WAAA;EAsBkB;;;EAfxC,KAAA;EAmCc;;;EA5Bd,UAAA,CAAW,EAAA;AAAA;;;;cAQA,UAAA,EAAU,UAAmB;AA8C1C;;;;;;;;;;AAyBA;;;;;;;;AAzBA,iBA1BgB,WAAA,CAAY,KAAA,EAAO,KAAK,EAAE,OAAA;;;;;;;;;;;;;;;;;;AAsDJ;;;;;iBA5BtB,2BAAA,UAA2B,OAAA,iCAAA,YAAA;UAAA,WAAA;AAAA;;;;;;;;;;;;;;;;iBAyB3B,kBAAA,mCACd,EAAA,MAAQ,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,GAChC,OAAA,GAAU,MAAA,wBACL,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA"}
+{"version":3,"file":"error-reporting.d.ts","names":[],"sources":["../src/error-reporting.ts"],"mappings":";;;;;;;;;;UAUiB;EACf;EACA;EACA,UAAU;EACV;IACE;IACA;IACA;IACA;;;;;;;;;cAUE;UACI;mBACS;;;;EAKjB,YAAY,OAAO,OAAO;;;;EAwD1B,gBAAgB;;;;EAOhB,SAAS,aAAa;;;;EAOtB;;;;EAOA,WAAW;;;;;cAQA,YAAU;;;;;;;;;;;;;;;;;;;iBAoBP,YAAY,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;;;;iBA0B1B,qCAA2B,wCAAA;UAA3B;;;;;;;;;;;;;;;;;iBAyBA,mBAAmB,yBAAyB,SAC1D,QAAQ,MAAM,UAAU,QAAQ,UAChC,UAAU,8BACL,MAAM,UAAU,QAAQ"}

package/dist/handlers.d.ts

@@ -1,5 +1,4 @@
-import { s as WrapStartHandlerConfig } from "./types-pQgmQa4j.js";
-
+import { s as WrapStartHandlerConfig } from "./types-zkKShSiK.js";
 //#region src/handlers.d.ts
 /**
  * Request handler type (compatible with TanStack Start handlers)

package/dist/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","names":[],"sources":["../src/handlers.ts"],"mappings":";;;;;AAQiB;KAKZ,cAAA,IACH,OAAA,EAAS,OAAA,EACT,IAAA;EAAS,OAAA,GAAU,MAAA;AAAA,MAChB,OAAA,CAAQ,QAAA,IAAY,QAAA;;;;;;;;;;;;;;;;AAAQ;AAgCjC;;;;;;;;;;;;;;iBAAgB,gBAAA,CACd,MAAA,GAAQ,sBAAA,IACN,OAAA,EAAS,cAAA,KAAmB,cAAA;AA6JhC;;;;;;;;;;;;;;;;AAE8C;;;;;;;;;;;AAF9C,iBAAgB,mBAAA,CACd,MAAA,GAAQ,IAAA,CAAK,sBAAA,yCACX,OAAA,EAAS,cAAA,KAAmB,cAAA"}
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../src/handlers.ts"],"mappings":";;;;;KAcK,kBACH,SAAS,SACT;EAAS,UAAU;MAChB,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCT,iBACd,SAAQ,0BACN,SAAS,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmKhB,oBACd,SAAQ,KAAK,+DACX,SAAS,mBAAmB"}

package/dist/handlers.js

@@ -1,8 +1,8 @@
-import { n as SPAN_ATTRIBUTES, t as DEFAULT_CONFIG } from "./types-BrccP0yX.js";
+import { i as SPAN_ATTRIBUTES, n as isRealError, r as DEFAULT_CONFIG, t as isControlFlowSignal } from "./control-flow-p-dnko0G.js";
 import { extractContextFromRequest } from "./context.js";
 import { t as isExcludedPath } from "./route-filter-dLg-j3jR.js";
 import { SpanStatusCode, context } from "@opentelemetry/api";
-import { init, trace } from "autotel";
+import { getActiveTraceContext, init, trace } from "autotel";
 
 //#region src/handlers.ts
 /**
@@ -63,7 +63,11 @@ function wrapStartHandler(config = {}) {
 			const parentContext = extractContextFromRequest(request);
 			return context.with(parentContext, async () => {
 				const spanName = `${request.method} ${url.pathname}`;
-				return trace(spanName, async (ctx) => {
+				return trace({
+					name: spanName,
+					isError: isRealError
+				}, async () => {
+					const ctx = getActiveTraceContext();
 					ctx.setAttributes({
 						[SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
 						[SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
@@ -98,10 +102,14 @@ function wrapStartHandler(config = {}) {
 					} catch (error) {
 						const duration = Date.now() - startTime;
 						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						if (isControlFlowSignal(error)) {
+							ctx.setStatus({ code: SpanStatusCode.OK });
+							throw error;
+						}
 						if (mergedConfig.captureErrors) ctx.recordError(error);
 						throw error;
 					}
-				});
+				})();
 			});
 		};
 	};
@@ -145,7 +153,11 @@ function createTracedHandler(config = {}) {
 			const parentContext = extractContextFromRequest(request);
 			return context.with(parentContext, async () => {
 				const spanName = `${request.method} ${url.pathname}`;
-				return trace(spanName, async (ctx) => {
+				return trace({
+					name: spanName,
+					isError: isRealError
+				}, async () => {
+					const ctx = getActiveTraceContext();
 					ctx.setAttributes({
 						[SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
 						[SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
@@ -179,10 +191,14 @@ function createTracedHandler(config = {}) {
 					} catch (error) {
 						const duration = Date.now() - startTime;
 						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						if (isControlFlowSignal(error)) {
+							ctx.setStatus({ code: SpanStatusCode.OK });
+							throw error;
+						}
 						if (mergedConfig.captureErrors) ctx.recordError(error);
 						throw error;
 					}
-				});
+				})();
 			});
 		};
 	};

package/dist/handlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.js","names":[],"sources":["../src/handlers.ts"],"sourcesContent":["import { context, SpanStatusCode } from '@opentelemetry/api';\nimport { trace, init, type TraceContext } from 'autotel';\nimport { extractContextFromRequest } from './context';\nimport { isExcludedPath } from './route-filter';\nimport {\n  type WrapStartHandlerConfig,\n  DEFAULT_CONFIG,\n  SPAN_ATTRIBUTES,\n} from './types';\n\n/**\n * Request handler type (compatible with TanStack Start handlers)\n */\ntype RequestHandler = (\n  request: Request,\n  opts?: { context?: Record<string, unknown> },\n) => Promise<Response> | Response;\n\n/**\n * Wrap a TanStack Start handler with OpenTelemetry tracing\n *\n * This function wraps the entire request handler to automatically create\n * spans for all incoming requests. It initializes OpenTelemetry and\n * provides comprehensive request tracing.\n *\n * @param config - Configuration options including OTLP endpoint and headers\n * @returns Function that wraps a request handler\n *\n * @example\n * ```typescript\n * // server.ts\n * import { createStartHandler, defaultStreamHandler } from '@tanstack/react-start/server';\n * import { wrapStartHandler } from 'autotel-tanstack/handlers';\n *\n * export default wrapStartHandler({\n *   service: 'my-app',\n *   endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,\n *   headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY },\n * })(createStartHandler(defaultStreamHandler));\n * ```\n *\n * @example\n * ```typescript\n * // With env var configuration (recommended for production)\n * // Set OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS\n * export default wrapStartHandler()(createStartHandler(defaultStreamHandler));\n * ```\n */\nexport function wrapStartHandler(\n  config: WrapStartHandlerConfig = {},\n): (handler: RequestHandler) => RequestHandler {\n  const mergedConfig = { ...DEFAULT_CONFIG, ...config };\n\n  // Initialize autotel with provided configuration\n  const service =\n    config.service || process.env.OTEL_SERVICE_NAME || 'tanstack-start';\n  const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n\n  // Parse headers from env if not provided\n  let headers = config.headers;\n  if (!headers && process.env.OTEL_EXPORTER_OTLP_HEADERS) {\n    headers = {};\n    const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',');\n    for (const pair of pairs) {\n      const [key, value] = pair.split('=');\n      if (key && value) {\n        headers[key.trim()] = value.trim();\n      }\n    }\n  }\n\n  // Initialize OpenTelemetry\n  init({\n    service,\n    endpoint,\n    headers,\n  });\n\n  return function wrapHandler(handler: RequestHandler): RequestHandler {\n    return async function tracedHandler(\n      request: Request,\n      opts?: { context?: Record<string, unknown> },\n    ): Promise<Response> {\n      const url = new URL(request.url);\n\n      // Check if path should be excluded\n      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {\n        return handler(request, opts);\n      }\n\n      // Extract parent context from request headers\n      const parentContext = extractContextFromRequest(request);\n\n      // Run within parent context\n      return context.with(parentContext, async () => {\n        const spanName = `${request.method} ${url.pathname}`;\n\n        return trace(spanName, async (ctx: TraceContext) => {\n          // Set HTTP semantic attributes\n          ctx.setAttributes({\n            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,\n            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,\n            [SPAN_ATTRIBUTES.URL_FULL]: request.url,\n            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',\n          });\n\n          if (url.search) {\n            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);\n          }\n\n          // Capture configured headers\n          if (mergedConfig.captureHeaders) {\n            for (const header of mergedConfig.captureHeaders) {\n              const value = request.headers.get(header);\n              if (value) {\n                ctx.setAttribute(\n                  `http.request.header.${header.toLowerCase()}`,\n                  value,\n                );\n              }\n            }\n          }\n\n          // Add custom attributes\n          if (config.customAttributes) {\n            const customAttrs = config.customAttributes({\n              type: 'request',\n              name: spanName,\n              request,\n            });\n            ctx.setAttributes(\n              customAttrs as Record<string, string | number | boolean>,\n            );\n          }\n\n          const startTime = Date.now();\n\n          try {\n            const response = await handler(request, opts);\n            const duration = Date.now() - startTime;\n\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,\n              response.status,\n            );\n\n            // Set status based on HTTP status code\n            if (response.status >= 400) {\n              ctx.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: `HTTP ${response.status}`,\n              });\n            } else {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n            }\n\n            return response;\n          } catch (error) {\n            const duration = Date.now() - startTime;\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n\n            if (mergedConfig.captureErrors) {\n              ctx.recordError(error);\n            }\n\n            throw error;\n          }\n        });\n      });\n    };\n  };\n}\n\n/**\n * Create a traced handler without auto-initialization\n *\n * Use this when you want to initialize autotel separately\n * (e.g., with more advanced configuration).\n *\n * @param config - Configuration options (excluding endpoint/headers)\n * @returns Function that wraps a request handler\n *\n * @example\n * ```typescript\n * import { init } from 'autotel';\n * import { createTracedHandler } from 'autotel-tanstack/handlers';\n *\n * // Initialize autotel with custom configuration\n * init({\n *   service: 'my-app',\n *   endpoint: 'https://api.honeycomb.io',\n *   instrumentations: [/* custom instrumentations *\\/],\n * });\n *\n * // Wrap handler without re-initializing\n * export default createTracedHandler({\n *   captureHeaders: ['x-request-id'],\n * })(createStartHandler(defaultStreamHandler));\n * ```\n */\nexport function createTracedHandler(\n  config: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'> = {},\n): (handler: RequestHandler) => RequestHandler {\n  const mergedConfig = { ...DEFAULT_CONFIG, ...config };\n\n  return function wrapHandler(handler: RequestHandler): RequestHandler {\n    return async function tracedHandler(\n      request: Request,\n      opts?: { context?: Record<string, unknown> },\n    ): Promise<Response> {\n      const url = new URL(request.url);\n\n      // Check if path should be excluded\n      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {\n        return handler(request, opts);\n      }\n\n      const parentContext = extractContextFromRequest(request);\n\n      return context.with(parentContext, async () => {\n        const spanName = `${request.method} ${url.pathname}`;\n\n        return trace(spanName, async (ctx: TraceContext) => {\n          ctx.setAttributes({\n            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,\n            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,\n            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',\n          });\n\n          if (url.search) {\n            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);\n          }\n\n          if (mergedConfig.captureHeaders) {\n            for (const header of mergedConfig.captureHeaders) {\n              const value = request.headers.get(header);\n              if (value) {\n                ctx.setAttribute(\n                  `http.request.header.${header.toLowerCase()}`,\n                  value,\n                );\n              }\n            }\n          }\n\n          if (config.customAttributes) {\n            const customAttrs = config.customAttributes({\n              type: 'request',\n              name: spanName,\n              request,\n            });\n            ctx.setAttributes(\n              customAttrs as Record<string, string | number | boolean>,\n            );\n          }\n\n          const startTime = Date.now();\n\n          try {\n            const response = await handler(request, opts);\n            const duration = Date.now() - startTime;\n\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,\n              response.status,\n            );\n\n            if (response.status >= 400) {\n              ctx.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: `HTTP ${response.status}`,\n              });\n            } else {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n            }\n\n            return response;\n          } catch (error) {\n            const duration = Date.now() - startTime;\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n\n            if (mergedConfig.captureErrors) {\n              ctx.recordError(error);\n            }\n\n            throw error;\n          }\n        });\n      });\n    };\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"handlers.js","names":[],"sources":["../src/handlers.ts"],"sourcesContent":["import { context, SpanStatusCode } from '@opentelemetry/api';\nimport { trace, init, getActiveTraceContext } from 'autotel';\nimport { extractContextFromRequest } from './context';\nimport { isControlFlowSignal, isRealError } from './control-flow';\nimport { isExcludedPath } from './route-filter';\nimport {\n  type WrapStartHandlerConfig,\n  DEFAULT_CONFIG,\n  SPAN_ATTRIBUTES,\n} from './types';\n\n/**\n * Request handler type (compatible with TanStack Start handlers)\n */\ntype RequestHandler = (\n  request: Request,\n  opts?: { context?: Record<string, unknown> },\n) => Promise<Response> | Response;\n\n/**\n * Wrap a TanStack Start handler with OpenTelemetry tracing\n *\n * This function wraps the entire request handler to automatically create\n * spans for all incoming requests. It initializes OpenTelemetry and\n * provides comprehensive request tracing.\n *\n * @param config - Configuration options including OTLP endpoint and headers\n * @returns Function that wraps a request handler\n *\n * @example\n * ```typescript\n * // server.ts\n * import { createStartHandler, defaultStreamHandler } from '@tanstack/react-start/server';\n * import { wrapStartHandler } from 'autotel-tanstack/handlers';\n *\n * export default wrapStartHandler({\n *   service: 'my-app',\n *   endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,\n *   headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY },\n * })(createStartHandler(defaultStreamHandler));\n * ```\n *\n * @example\n * ```typescript\n * // With env var configuration (recommended for production)\n * // Set OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS\n * export default wrapStartHandler()(createStartHandler(defaultStreamHandler));\n * ```\n */\nexport function wrapStartHandler(\n  config: WrapStartHandlerConfig = {},\n): (handler: RequestHandler) => RequestHandler {\n  const mergedConfig = { ...DEFAULT_CONFIG, ...config };\n\n  // Initialize autotel with provided configuration\n  const service =\n    config.service || process.env.OTEL_SERVICE_NAME || 'tanstack-start';\n  const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n\n  // Parse headers from env if not provided\n  let headers = config.headers;\n  if (!headers && process.env.OTEL_EXPORTER_OTLP_HEADERS) {\n    headers = {};\n    const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',');\n    for (const pair of pairs) {\n      const [key, value] = pair.split('=');\n      if (key && value) {\n        headers[key.trim()] = value.trim();\n      }\n    }\n  }\n\n  // Initialize OpenTelemetry\n  init({\n    service,\n    endpoint,\n    headers,\n  });\n\n  return function wrapHandler(handler: RequestHandler): RequestHandler {\n    return async function tracedHandler(\n      request: Request,\n      opts?: { context?: Record<string, unknown> },\n    ): Promise<Response> {\n      const url = new URL(request.url);\n\n      // Check if path should be excluded\n      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {\n        return handler(request, opts);\n      }\n\n      // Extract parent context from request headers\n      const parentContext = extractContextFromRequest(request);\n\n      // Run within parent context\n      return context.with(parentContext, async () => {\n        const spanName = `${request.method} ${url.pathname}`;\n\n        return trace({ name: spanName, isError: isRealError }, async () => {\n          const ctx = getActiveTraceContext()!;\n          // Set HTTP semantic attributes\n          ctx.setAttributes({\n            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,\n            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,\n            [SPAN_ATTRIBUTES.URL_FULL]: request.url,\n            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',\n          });\n\n          if (url.search) {\n            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);\n          }\n\n          // Capture configured headers\n          if (mergedConfig.captureHeaders) {\n            for (const header of mergedConfig.captureHeaders) {\n              const value = request.headers.get(header);\n              if (value) {\n                ctx.setAttribute(\n                  `http.request.header.${header.toLowerCase()}`,\n                  value,\n                );\n              }\n            }\n          }\n\n          // Add custom attributes\n          if (config.customAttributes) {\n            const customAttrs = config.customAttributes({\n              type: 'request',\n              name: spanName,\n              request,\n            });\n            ctx.setAttributes(\n              customAttrs as Record<string, string | number | boolean>,\n            );\n          }\n\n          const startTime = Date.now();\n\n          try {\n            const response = await handler(request, opts);\n            const duration = Date.now() - startTime;\n\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,\n              response.status,\n            );\n\n            // Set status based on HTTP status code\n            if (response.status >= 400) {\n              ctx.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: `HTTP ${response.status}`,\n              });\n            } else {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n            }\n\n            return response;\n          } catch (error) {\n            const duration = Date.now() - startTime;\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n\n            if (isControlFlowSignal(error)) {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n              throw error;\n            }\n\n            if (mergedConfig.captureErrors) {\n              ctx.recordError(error);\n            }\n\n            throw error;\n          }\n        })();\n      });\n    };\n  };\n}\n\n/**\n * Create a traced handler without auto-initialization\n *\n * Use this when you want to initialize autotel separately\n * (e.g., with more advanced configuration).\n *\n * @param config - Configuration options (excluding endpoint/headers)\n * @returns Function that wraps a request handler\n *\n * @example\n * ```typescript\n * import { init } from 'autotel';\n * import { createTracedHandler } from 'autotel-tanstack/handlers';\n *\n * // Initialize autotel with custom configuration\n * init({\n *   service: 'my-app',\n *   endpoint: 'https://api.honeycomb.io',\n *   instrumentations: [/* custom instrumentations *\\/],\n * });\n *\n * // Wrap handler without re-initializing\n * export default createTracedHandler({\n *   captureHeaders: ['x-request-id'],\n * })(createStartHandler(defaultStreamHandler));\n * ```\n */\nexport function createTracedHandler(\n  config: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'> = {},\n): (handler: RequestHandler) => RequestHandler {\n  const mergedConfig = { ...DEFAULT_CONFIG, ...config };\n\n  return function wrapHandler(handler: RequestHandler): RequestHandler {\n    return async function tracedHandler(\n      request: Request,\n      opts?: { context?: Record<string, unknown> },\n    ): Promise<Response> {\n      const url = new URL(request.url);\n\n      // Check if path should be excluded\n      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {\n        return handler(request, opts);\n      }\n\n      const parentContext = extractContextFromRequest(request);\n\n      return context.with(parentContext, async () => {\n        const spanName = `${request.method} ${url.pathname}`;\n\n        return trace({ name: spanName, isError: isRealError }, async () => {\n          const ctx = getActiveTraceContext()!;\n          ctx.setAttributes({\n            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,\n            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,\n            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',\n          });\n\n          if (url.search) {\n            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);\n          }\n\n          if (mergedConfig.captureHeaders) {\n            for (const header of mergedConfig.captureHeaders) {\n              const value = request.headers.get(header);\n              if (value) {\n                ctx.setAttribute(\n                  `http.request.header.${header.toLowerCase()}`,\n                  value,\n                );\n              }\n            }\n          }\n\n          if (config.customAttributes) {\n            const customAttrs = config.customAttributes({\n              type: 'request',\n              name: spanName,\n              request,\n            });\n            ctx.setAttributes(\n              customAttrs as Record<string, string | number | boolean>,\n            );\n          }\n\n          const startTime = Date.now();\n\n          try {\n            const response = await handler(request, opts);\n            const duration = Date.now() - startTime;\n\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,\n              response.status,\n            );\n\n            if (response.status >= 400) {\n              ctx.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: `HTTP ${response.status}`,\n              });\n            } else {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n            }\n\n            return response;\n          } catch (error) {\n            const duration = Date.now() - startTime;\n            ctx.setAttribute(\n              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,\n              duration,\n            );\n\n            if (isControlFlowSignal(error)) {\n              ctx.setStatus({ code: SpanStatusCode.OK });\n              throw error;\n            }\n\n            if (mergedConfig.captureErrors) {\n              ctx.recordError(error);\n            }\n\n            throw error;\n          }\n        })();\n      });\n    };\n  };\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,15 +1,14 @@
-import { n as instrument, t as InstrumentOptions } from "./instrument-DS7YCE1R.js";
-import { a as TraceServerFnConfig, i as TraceLoaderConfig, n as SPAN_ATTRIBUTES, o as TracingMiddlewareConfig, r as TanStackInstrumentationConfig, s as WrapStartHandlerConfig, t as DEFAULT_CONFIG } from "./types-pQgmQa4j.js";
+import { n as instrument, t as InstrumentOptions } from "./instrument-B4bfWksz.js";
+import { a as TraceServerFnConfig, i as TraceLoaderConfig, n as SPAN_ATTRIBUTES, o as TracingMiddlewareConfig, r as TanStackInstrumentationConfig, s as WrapStartHandlerConfig, t as DEFAULT_CONFIG } from "./types-zkKShSiK.js";
 import { MiddlewareHandler, createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from "./middleware.js";
 import { createTracedServerFnFactory, traceServerFn } from "./server-functions.js";
-import { n as traceBeforeLoad, r as traceLoader, t as createTracedRoute } from "./loaders-dci0y1cD.js";
+import { n as traceBeforeLoad, r as traceLoader, t as createTracedRoute } from "./loaders-DMUCHc32.js";
 import { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext } from "./context.js";
 import { DebugHeadersConfig, debugHeadersMiddleware } from "./debug-headers.js";
 import { ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting } from "./error-reporting.js";
 import { createTracedHandler, wrapStartHandler } from "./handlers.js";
 import { TimingStats, createMetricsHandler, metricsCollector, recordTiming } from "./metrics.js";
 import { flush, init, shutdown, span, trace } from "autotel";
-
 //#region src/env.d.ts
 /**
  * Environment detection utilities

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/env.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBASgB,SAAA;;;;iBAaA,MAAA;AAbhB;;;;AAAyB;AAAzB,iBA0BgB,YAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/env.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBASgB;;;;iBAaA;;;;;;iBAaA"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as SPAN_ATTRIBUTES, t as DEFAULT_CONFIG } from "./types-BrccP0yX.js";
+import { i as SPAN_ATTRIBUTES, r as DEFAULT_CONFIG } from "./control-flow-p-dnko0G.js";
 import { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext } from "./context.js";
 import { n as isNode, r as isServerSide, t as isBrowser } from "./env-BpFWNnpL.js";
 import { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from "./middleware.js";

package/dist/{instrument-DS7YCE1R.d.ts → instrument-B4bfWksz.d.ts}

@@ -1,5 +1,4 @@
 import { AutotelConfig } from "autotel";
-
 //#region src/instrument.d.ts
 type InstrumentOptions = Omit<AutotelConfig, 'service'> & {
   service?: string;
@@ -7,4 +6,4 @@ type InstrumentOptions = Omit<AutotelConfig, 'service'> & {
 declare function instrument(options?: InstrumentOptions): void;
 //#endregion
 export { instrument as n, InstrumentOptions as t };
-//# sourceMappingURL=instrument-DS7YCE1R.d.ts.map
+//# sourceMappingURL=instrument-B4bfWksz.d.ts.map

package/dist/instrument-B4bfWksz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument-B4bfWksz.d.ts","names":[],"sources":["../src/instrument.ts"],"mappings":";;KA4CY,oBAAoB,KAAK;EACnC;;iBAuBc,WAAW,UAAS"}