autotel-tanstack 1.13.29 → 1.13.31

package/dist/browser/metrics.js

@@ -1,3 +1,49 @@
-export { createMetricsHandler, getMetrics, metricsCollector, recordError, recordTiming, resetMetrics } from '../chunk-UMEJU65Q.js';
-//# sourceMappingURL=metrics.js.map
+//#region src/browser/metrics.ts
+/**
+* Browser stub: Returns empty metrics
+*/
+function getMetrics() {
+	return {
+		requestCount: 0,
+		errorCount: 0,
+		avgLatency: 0,
+		p50Latency: 0,
+		p95Latency: 0,
+		p99Latency: 0,
+		requestsPerSecond: 0,
+		endpoints: {}
+	};
+}
+/**
+* Browser stub: No-op
+*/
+function recordTiming(name, durationMs) {}
+/**
+* Browser stub: No-op
+*/
+function recordError(name) {}
+/**
+* Browser stub: No-op
+*/
+function resetMetrics() {}
+/**
+* Browser stub: No-op metrics collector
+*/
+const metricsCollector = {
+	recordTiming,
+	recordError,
+	getMetrics,
+	reset: resetMetrics
+};
+/**
+* Browser stub: Returns JSON Response with empty metrics
+*/
+function createMetricsHandler() {
+	return () => {
+		return Response.json(getMetrics());
+	};
+}
+
+//#endregion
+export { createMetricsHandler, getMetrics, metricsCollector, recordError, recordTiming, resetMetrics };
 //# sourceMappingURL=metrics.js.map

package/dist/browser/metrics.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"metrics.js"}
+{"version":3,"file":"metrics.js","names":[],"sources":["../../src/browser/metrics.ts"],"sourcesContent":["/**\n * Browser stub for metrics module\n *\n * Metrics collection only happens on the server.\n * In browser, these are no-op functions.\n */\n\n/**\n * Metrics data structure (stub)\n */\nexport interface MetricsData {\n  requestCount: number;\n  errorCount: number;\n  avgLatency: number;\n  p50Latency: number;\n  p95Latency: number;\n  p99Latency: number;\n  requestsPerSecond: number;\n  endpoints: Record<\n    string,\n    {\n      count: number;\n      errors: number;\n      avgLatency: number;\n    }\n  >;\n}\n\n/**\n * Browser stub: Returns empty metrics\n */\nexport function getMetrics(): MetricsData {\n  return {\n    requestCount: 0,\n    errorCount: 0,\n    avgLatency: 0,\n    p50Latency: 0,\n    p95Latency: 0,\n    p99Latency: 0,\n    requestsPerSecond: 0,\n    endpoints: {},\n  };\n}\n\n/**\n * Browser stub: No-op\n */\nexport function recordTiming(name: string, durationMs: number): void {\n  void name;\n  void durationMs;\n  // No-op in browser\n}\n\n/**\n * Browser stub: No-op\n */\nexport function recordError(name: string): void {\n  void name;\n  // No-op in browser\n}\n\n/**\n * Browser stub: No-op\n */\nexport function resetMetrics(): void {\n  // No-op in browser\n}\n\n/**\n * Browser stub: No-op metrics collector\n */\nexport const metricsCollector = {\n  recordTiming: recordTiming,\n  recordError: recordError,\n  getMetrics: getMetrics,\n  reset: resetMetrics,\n};\n\n/**\n * Browser stub: Returns JSON Response with empty metrics\n */\nexport function createMetricsHandler(): () => Response {\n  return () => {\n    return Response.json(getMetrics());\n  };\n}\n"],"mappings":";;;;AA+BA,SAAgB,aAA0B;CACxC,OAAO;EACL,cAAc;EACd,YAAY;EACZ,YAAY;EACZ,YAAY;EACZ,YAAY;EACZ,YAAY;EACZ,mBAAmB;EACnB,WAAW,CAAC;CACd;AACF;;;;AAKA,SAAgB,aAAa,MAAc,YAA0B,CAIrE;;;;AAKA,SAAgB,YAAY,MAAoB,CAGhD;;;;AAKA,SAAgB,eAAqB,CAErC;;;;AAKA,MAAa,mBAAmB;CAChB;CACD;CACD;CACZ,OAAO;AACT;;;;AAKA,SAAgB,uBAAuC;CACrD,aAAa;EACX,OAAO,SAAS,KAAK,WAAW,CAAC;CACnC;AACF"}

package/dist/browser/middleware.d.ts

@@ -0,0 +1,42 @@
+import { s as TracingMiddlewareConfig } from "../types-BJ7FyVoX.js";
+
+//#region src/browser/middleware.d.ts
+/**
+ * Generic middleware handler type
+ */
+interface MiddlewareHandler<TContext = unknown> {
+  (opts: {
+    next: (ctx?: Partial<TContext>) => Promise<TContext>;
+    context: TContext;
+    request?: Request;
+    pathname?: string;
+    data?: unknown;
+    method?: string;
+    filename?: string;
+    functionId?: string;
+    signal?: AbortSignal;
+  }): Promise<TContext>;
+}
+/**
+ * Browser stub: Returns pass-through middleware
+ */
+declare function createTracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+/**
+ * Browser stub: Returns pass-through middleware
+ */
+declare function tracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+/**
+ * Browser stub: Returns pass-through middleware
+ */
+declare function functionTracingMiddleware<TContext = unknown>(config?: Omit<TracingMiddlewareConfig, 'type'>): MiddlewareHandler<TContext>;
+/**
+ * Browser stub: Returns pass-through handler for createMiddleware().server()
+ */
+declare function createTracingServerHandler<TContext = unknown>(config?: TracingMiddlewareConfig): (opts: {
+  next: (ctx?: Partial<TContext>) => Promise<TContext>;
+  context: TContext;
+  request?: Request;
+}) => Promise<TContext>;
+//#endregion
+export { MiddlewareHandler, createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware };
+//# sourceMappingURL=middleware.d.ts.map

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

@@ -0,0 +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"}

package/dist/browser/middleware.js

@@ -1,3 +1,37 @@
-export { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from '../chunk-A7WMQ2BC.js';
-//# sourceMappingURL=middleware.js.map
+//#region src/browser/middleware.ts
+/**
+* Browser stub: Returns pass-through middleware
+*/
+function createTracingMiddleware(config) {
+	return async function noopMiddleware(opts) {
+		return opts.next();
+	};
+}
+/**
+* Browser stub: Returns pass-through middleware
+*/
+function tracingMiddleware(config) {
+	return async function noopMiddleware(opts) {
+		return opts.next();
+	};
+}
+/**
+* Browser stub: Returns pass-through middleware
+*/
+function functionTracingMiddleware(config) {
+	return async function noopMiddleware(opts) {
+		return opts.next();
+	};
+}
+/**
+* Browser stub: Returns pass-through handler for createMiddleware().server()
+*/
+function createTracingServerHandler(config) {
+	return async function noopHandler(opts) {
+		return opts.next();
+	};
+}
+
+//#endregion
+export { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware };
 //# sourceMappingURL=middleware.js.map

package/dist/browser/middleware.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"middleware.js"}
+{"version":3,"file":"middleware.js","names":[],"sources":["../../src/browser/middleware.ts"],"sourcesContent":["/**\n * Browser stub for middleware module\n *\n * In browser environments, these functions return pass-through middleware\n * that just calls next() without any tracing overhead.\n */\n\nimport type { TracingMiddlewareConfig } from './types';\n\n/**\n * Generic middleware handler type\n */\nexport interface MiddlewareHandler<TContext = unknown> {\n  (opts: {\n    next: (ctx?: Partial<TContext>) => Promise<TContext>;\n    context: TContext;\n    request?: Request;\n    pathname?: string;\n    data?: unknown;\n    method?: string;\n    filename?: string;\n    functionId?: string;\n    signal?: AbortSignal;\n  }): Promise<TContext>;\n}\n\n/**\n * Browser stub: Returns pass-through middleware\n */\nexport function createTracingMiddleware<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): MiddlewareHandler<TContext> {\n  void config;\n  return async function noopMiddleware(opts) {\n    return opts.next();\n  };\n}\n\n/**\n * Browser stub: Returns pass-through middleware\n */\nexport function tracingMiddleware<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): MiddlewareHandler<TContext> {\n  void config;\n  return async function noopMiddleware(opts) {\n    return opts.next();\n  };\n}\n\n/**\n * Browser stub: Returns pass-through middleware\n */\nexport function functionTracingMiddleware<TContext = unknown>(\n  config?: Omit<TracingMiddlewareConfig, 'type'>,\n): MiddlewareHandler<TContext> {\n  void config;\n  return async function noopMiddleware(opts) {\n    return opts.next();\n  };\n}\n\n/**\n * Browser stub: Returns pass-through handler for createMiddleware().server()\n */\nexport function createTracingServerHandler<TContext = unknown>(\n  config?: TracingMiddlewareConfig,\n): (opts: {\n  next: (ctx?: Partial<TContext>) => Promise<TContext>;\n  context: TContext;\n  request?: Request;\n}) => Promise<TContext> {\n  void config;\n  return async function noopHandler(opts) {\n    return opts.next();\n  };\n}\n"],"mappings":";;;;AA6BA,SAAgB,wBACd,QAC6B;CAE7B,OAAO,eAAe,eAAe,MAAM;EACzC,OAAO,KAAK,KAAK;CACnB;AACF;;;;AAKA,SAAgB,kBACd,QAC6B;CAE7B,OAAO,eAAe,eAAe,MAAM;EACzC,OAAO,KAAK,KAAK;CACnB;AACF;;;;AAKA,SAAgB,0BACd,QAC6B;CAE7B,OAAO,eAAe,eAAe,MAAM;EACzC,OAAO,KAAK,KAAK;CACnB;AACF;;;;AAKA,SAAgB,2BACd,QAKsB;CAEtB,OAAO,eAAe,YAAY,MAAM;EACtC,OAAO,KAAK,KAAK;CACnB;AACF"}

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

@@ -0,0 +1,14 @@
+import { o as TraceServerFnConfig } from "../types-BJ7FyVoX.js";
+
+//#region src/browser/server-functions.d.ts
+/**
+ * Browser stub: Returns the server function unchanged
+ */
+declare function traceServerFn<T extends (...args: unknown[]) => Promise<unknown>>(serverFn: T, config?: TraceServerFnConfig): T;
+/**
+ * Browser stub: Returns the createServerFn unchanged
+ */
+declare function createTracedServerFnFactory<TCreateServerFn extends (...args: unknown[]) => unknown>(createServerFnOriginal: TCreateServerFn, defaultConfig?: Omit<TraceServerFnConfig, 'name'>): TCreateServerFn;
+//#endregion
+export { createTracedServerFnFactory, traceServerFn };
+//# sourceMappingURL=server-functions.d.ts.map

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

@@ -0,0 +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"}

package/dist/browser/server-functions.js

@@ -1,3 +1,17 @@
-export { createTracedServerFnFactory, traceServerFn } from '../chunk-CSFIPJC2.js';
-//# sourceMappingURL=server-functions.js.map
+//#region src/browser/server-functions.ts
+/**
+* Browser stub: Returns the server function unchanged
+*/
+function traceServerFn(serverFn, config) {
+	return serverFn;
+}
+/**
+* Browser stub: Returns the createServerFn unchanged
+*/
+function createTracedServerFnFactory(createServerFnOriginal, defaultConfig) {
+	return createServerFnOriginal;
+}
+
+//#endregion
+export { createTracedServerFnFactory, traceServerFn };
 //# sourceMappingURL=server-functions.js.map

package/dist/browser/server-functions.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"server-functions.js"}
+{"version":3,"file":"server-functions.js","names":[],"sources":["../../src/browser/server-functions.ts"],"sourcesContent":["/**\n * Browser stub for server-functions module\n *\n * In browser environments, these functions are no-ops that just return\n * the original functions without any tracing overhead.\n */\n\nimport type { TraceServerFnConfig } from './types';\n\n/**\n * Browser stub: Returns the server function unchanged\n */\nexport function traceServerFn<\n  T extends (...args: unknown[]) => Promise<unknown>,\n>(serverFn: T, config?: TraceServerFnConfig): T {\n  void config;\n  return serverFn;\n}\n\n/**\n * Browser stub: Returns the createServerFn unchanged\n */\nexport function createTracedServerFnFactory<\n  TCreateServerFn extends (...args: unknown[]) => unknown,\n>(\n  createServerFnOriginal: TCreateServerFn,\n  defaultConfig?: Omit<TraceServerFnConfig, 'name'>,\n): TCreateServerFn {\n  void defaultConfig;\n  return createServerFnOriginal;\n}\n"],"mappings":";;;;AAYA,SAAgB,cAEd,UAAa,QAAiC;CAE9C,OAAO;AACT;;;;AAKA,SAAgB,4BAGd,wBACA,eACiB;CAEjB,OAAO;AACT"}

package/dist/browser/testing.d.ts

@@ -0,0 +1,85 @@
+//#region src/browser/testing.d.ts
+/**
+ * Browser stub for testing module
+ *
+ * Testing utilities are server-side only.
+ * In browser, these return no-op implementations.
+ */
+/**
+ * Test span structure (stub)
+ */
+interface TestSpan {
+  name: string;
+  attributes: Record<string, unknown>;
+  status: {
+    code: number;
+    message?: string;
+  };
+  events: Array<{
+    name: string;
+    attributes?: Record<string, unknown>;
+  }>;
+  duration: number;
+}
+/**
+ * Test collector structure (stub)
+ */
+interface TestCollector {
+  getSpans(): TestSpan[];
+  getSpansByName(name: string): TestSpan[];
+  clear(): void;
+  waitForSpans(count: number, timeout?: number): Promise<TestSpan[]>;
+}
+/**
+ * Browser stub: Returns empty collector
+ */
+declare function createTestCollector(): TestCollector;
+/**
+ * Browser stub: No-op
+ */
+declare function assertSpanCreated(collector: TestCollector, name: string): void;
+/**
+ * Browser stub: No-op
+ */
+declare function assertSpanHasAttribute(collector: TestCollector, name: string, key: string, value?: unknown): void;
+/**
+ * Serialized span type (browser stub - mirrors server SerializedSpan).
+ *
+ * Defined as a `type` (not `interface`) so it is assignable to
+ * `Record<string, unknown>` in TypeScript 6+ strict mode.
+ */
+type SerializedSpan = {
+  name: string;
+  spanId: string;
+  traceId: string;
+  parentSpanId?: string;
+  attributes?: Record<string, unknown>;
+  status: {
+    code: number;
+    message?: string;
+  };
+  durationMs: number;
+};
+/**
+ * Accepts either a raw `Request` (legacy) or a TanStack Router context
+ * object containing `{ request: Request }` (Router 1.168+).
+ */
+type HandlerInput = Request | {
+  request: Request;
+};
+type CreateFileRoute = (path: string) => (options: any) => any;
+/**
+ * Browser stub: createTestSpansRoute is server-only.
+ */
+declare function createTestSpansRoute(createFileRoute: CreateFileRoute, path?: string): unknown;
+/**
+ * Browser stub: test-spans handlers are server-only.
+ * Returns no-op handlers that always return 404.
+ */
+declare function createTestSpansHandlers(): {
+  GET: (input: HandlerInput) => Response;
+  DELETE: (input: HandlerInput) => Response;
+};
+//#endregion
+export { SerializedSpan, TestCollector, TestSpan, assertSpanCreated, assertSpanHasAttribute, createTestCollector, createTestSpansHandlers, createTestSpansRoute };
+//# sourceMappingURL=testing.d.ts.map

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

@@ -0,0 +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"}

package/dist/browser/testing.js

@@ -1,3 +1,44 @@
-export { assertSpanCreated, assertSpanHasAttribute, createTestCollector, createTestSpansHandlers, createTestSpansRoute } from '../chunk-YQYYPJCK.js';
-//# sourceMappingURL=testing.js.map
+//#region src/browser/testing.ts
+/**
+* Browser stub: Returns empty collector
+*/
+function createTestCollector() {
+	return {
+		getSpans: () => [],
+		getSpansByName: () => [],
+		clear: () => {},
+		waitForSpans: async () => []
+	};
+}
+/**
+* Browser stub: No-op
+*/
+function assertSpanCreated(collector, name) {}
+/**
+* Browser stub: No-op
+*/
+function assertSpanHasAttribute(collector, name, key, value) {}
+/**
+* Browser stub: createTestSpansRoute is server-only.
+*/
+function createTestSpansRoute(createFileRoute, path) {
+	throw new Error("createTestSpansRoute is server-only");
+}
+/**
+* Browser stub: test-spans handlers are server-only.
+* Returns no-op handlers that always return 404.
+*/
+function createTestSpansHandlers() {
+	return {
+		GET(input) {
+			return Response.json({ error: "createTestSpansHandlers is server-only" }, { status: 404 });
+		},
+		DELETE(input) {
+			return Response.json({ error: "createTestSpansHandlers is server-only" }, { status: 404 });
+		}
+	};
+}
+
+//#endregion
+export { assertSpanCreated, assertSpanHasAttribute, createTestCollector, createTestSpansHandlers, createTestSpansRoute };
 //# sourceMappingURL=testing.js.map

package/dist/browser/testing.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"testing.js"}
+{"version":3,"file":"testing.js","names":[],"sources":["../../src/browser/testing.ts"],"sourcesContent":["/**\n * Browser stub for testing module\n *\n * Testing utilities are server-side only.\n * In browser, these return no-op implementations.\n */\n\n/**\n * Test span structure (stub)\n */\nexport interface TestSpan {\n  name: string;\n  attributes: Record<string, unknown>;\n  status: { code: number; message?: string };\n  events: Array<{ name: string; attributes?: Record<string, unknown> }>;\n  duration: number;\n}\n\n/**\n * Test collector structure (stub)\n */\nexport interface TestCollector {\n  getSpans(): TestSpan[];\n  getSpansByName(name: string): TestSpan[];\n  clear(): void;\n  waitForSpans(count: number, timeout?: number): Promise<TestSpan[]>;\n}\n\n/**\n * Browser stub: Returns empty collector\n */\nexport function createTestCollector(): TestCollector {\n  return {\n    getSpans: () => [],\n    getSpansByName: () => [],\n    clear: () => {},\n    waitForSpans: async () => [],\n  };\n}\n\n/**\n * Browser stub: No-op\n */\nexport function assertSpanCreated(\n  collector: TestCollector,\n  name: string,\n): void {\n  void collector;\n  void name;\n  // No-op in browser\n}\n\n/**\n * Browser stub: No-op\n */\nexport function assertSpanHasAttribute(\n  collector: TestCollector,\n  name: string,\n  key: string,\n  value?: unknown,\n): void {\n  void collector;\n  void name;\n  void key;\n  void value;\n  // No-op in browser\n}\n\n/**\n * Serialized span type (browser stub - mirrors server SerializedSpan).\n *\n * Defined as a `type` (not `interface`) so it is assignable to\n * `Record<string, unknown>` in TypeScript 6+ strict mode.\n */\nexport type SerializedSpan = {\n  name: string;\n  spanId: string;\n  traceId: string;\n  parentSpanId?: string;\n  attributes?: Record<string, unknown>;\n  status: { code: number; message?: string };\n  durationMs: number;\n};\n\n/**\n * Accepts either a raw `Request` (legacy) or a TanStack Router context\n * object containing `{ request: Request }` (Router 1.168+).\n */\ntype HandlerInput = Request | { request: Request };\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CreateFileRoute = (path: string) => (options: any) => any;\n\n/**\n * Browser stub: createTestSpansRoute is server-only.\n */\nexport function createTestSpansRoute(\n  createFileRoute: CreateFileRoute,\n  path?: string,\n): unknown {\n  void createFileRoute;\n  void path;\n  throw new Error('createTestSpansRoute is server-only');\n}\n\n/**\n * Browser stub: test-spans handlers are server-only.\n * Returns no-op handlers that always return 404.\n */\nexport function createTestSpansHandlers(): {\n  GET: (input: HandlerInput) => Response;\n  DELETE: (input: HandlerInput) => Response;\n} {\n  return {\n    GET(input: HandlerInput): Response {\n      void input;\n      return Response.json(\n        { error: 'createTestSpansHandlers is server-only' },\n        { status: 404 },\n      );\n    },\n    DELETE(input: HandlerInput): Response {\n      void input;\n      return Response.json(\n        { error: 'createTestSpansHandlers is server-only' },\n        { status: 404 },\n      );\n    },\n  };\n}\n"],"mappings":";;;;AA+BA,SAAgB,sBAAqC;CACnD,OAAO;EACL,gBAAgB,CAAC;EACjB,sBAAsB,CAAC;EACvB,aAAa,CAAC;EACd,cAAc,YAAY,CAAC;CAC7B;AACF;;;;AAKA,SAAgB,kBACd,WACA,MACM,CAIR;;;;AAKA,SAAgB,uBACd,WACA,MACA,KACA,OACM,CAMR;;;;AA8BA,SAAgB,qBACd,iBACA,MACS;CAGT,MAAM,IAAI,MAAM,qCAAqC;AACvD;;;;;AAMA,SAAgB,0BAGd;CACA,OAAO;EACL,IAAI,OAA+B;GAEjC,OAAO,SAAS,KACd,EAAE,OAAO,yCAAyC,GAClD,EAAE,QAAQ,IAAI,CAChB;EACF;EACA,OAAO,OAA+B;GAEpC,OAAO,SAAS,KACd,EAAE,OAAO,yCAAyC,GAClD,EAAE,QAAQ,IAAI,CAChB;EACF;CACF;AACF"}

package/dist/browser/types.d.ts

@@ -0,0 +1,2 @@
+import { a as TraceLoaderConfig, c as WrapStartHandlerConfig, i as TanStackInstrumentationConfig, n as DEFAULT_CONFIG, o as TraceServerFnConfig, r as SPAN_ATTRIBUTES, s as TracingMiddlewareConfig, t as Attributes } from "../types-BJ7FyVoX.js";
+export { Attributes, DEFAULT_CONFIG, SPAN_ATTRIBUTES, TanStackInstrumentationConfig, TraceLoaderConfig, TraceServerFnConfig, TracingMiddlewareConfig, WrapStartHandlerConfig };

package/dist/browser/types.js

@@ -1,3 +1,38 @@
-export { DEFAULT_CONFIG, SPAN_ATTRIBUTES } from '../chunk-MFYOV2SF.js';
-//# sourceMappingURL=types.js.map
+//#region src/browser/types.ts
+/**
+* Default configuration values
+*/
+const DEFAULT_CONFIG = {
+	captureArgs: true,
+	captureResults: false,
+	captureErrors: true,
+	captureHeaders: ["x-request-id"],
+	excludePaths: [],
+	sampling: "adaptive"
+};
+/**
+* Span attribute keys (stub - values are strings)
+*/
+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
+export { DEFAULT_CONFIG, SPAN_ATTRIBUTES };
 //# sourceMappingURL=types.js.map

package/dist/browser/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/browser/types.ts"],"sourcesContent":["/**\n * Browser stub for types module\n *\n * Provides type definitions without importing from @opentelemetry/api\n */\n\n/**\n * OpenTelemetry-compatible Attributes type (browser stub)\n */\nexport type Attributes = Record<string, string | number | boolean | undefined>;\n\n/**\n * Configuration options for TanStack Start instrumentation\n */\nexport interface TanStackInstrumentationConfig {\n  service?: string;\n  captureArgs?: boolean;\n  captureResults?: boolean;\n  captureErrors?: boolean;\n  captureHeaders?: string[];\n  excludePaths?: (string | RegExp)[];\n  sampling?: 'always' | 'adaptive' | 'never';\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  type?: 'request' | 'function';\n}\n\n/**\n * Configuration for server function tracing\n */\nexport interface TraceServerFnConfig {\n  name?: string;\n  captureArgs?: boolean;\n  captureResults?: boolean;\n}\n\n/**\n * Configuration for loader tracing\n */\nexport interface TraceLoaderConfig {\n  name?: string;\n  captureParams?: boolean;\n  captureResult?: boolean;\n}\n\n/**\n * Configuration for handler wrapper\n */\nexport interface WrapStartHandlerConfig extends TanStackInstrumentationConfig {\n  endpoint?: string;\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 (stub - values are strings)\n */\nexport const SPAN_ATTRIBUTES = {\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  RPC_SYSTEM: 'rpc.system',\n  RPC_METHOD: 'rpc.method',\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"],"mappings":";;;;AAmEA,MAAa,iBAET;CACF,aAAa;CACb,gBAAgB;CAChB,eAAe;CACf,gBAAgB,CAAC,cAAc;CAC/B,cAAc,CAAC;CACf,UAAU;AACZ;;;;AAKA,MAAa,kBAAkB;CAC7B,qBAAqB;CACrB,2BAA2B;CAC3B,UAAU;CACV,WAAW;CACX,UAAU;CACV,YAAY;CACZ,YAAY;CACZ,eAAe;CACf,yBAAyB;CACzB,2BAA2B;CAC3B,yBAAyB;CACzB,2BAA2B;CAC3B,0BAA0B;CAC1B,sBAAsB;CACtB,wBAAwB;CACxB,0BAA0B;CAC1B,8BAA8B;AAChC"}

package/dist/context.d.ts

@@ -1,5 +1,6 @@
-import { Context } from '@opentelemetry/api';
+import { Context } from "@opentelemetry/api";
 
+//#region src/context.d.ts
 /**
  * Type representing values that can be used to initialize Headers
  * This is equivalent to the DOM's HeadersInit type but works in Node.js
@@ -90,5 +91,6 @@ declare function runInContext<T>(parentContext: Context, fn: () => T): T;
  * @returns The current active OpenTelemetry context
  */
 declare function getActiveContext(): Context;
-
-export { type HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext };
+//#endregion
+export { HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext };
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;AAWA;;KAAY,eAAA,GACR,OAAA,GACA,MAAM;;AAAA;AAqBV;;;;;;;;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"}

package/dist/context.js

@@ -1,4 +1,113 @@
-export { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext } from './chunk-NTY64BKS.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=context.js.map
+import { ROOT_CONTEXT, context, propagation } from "@opentelemetry/api";
+
+//#region src/context.ts
+/**
+* Extract OpenTelemetry context from HTTP request headers
+*
+* This function extracts W3C Trace Context (traceparent, tracestate)
+* and Baggage from request headers to enable distributed tracing.
+*
+* @param request - The incoming HTTP request
+* @returns OpenTelemetry context with extracted trace information
+*
+* @example
+* ```typescript
+* const parentContext = extractContextFromRequest(request);
+* context.with(parentContext, async () => {
+*   // Spans created here will be children of the extracted context
+*   await trace('my-operation', async (ctx) => { ... });
+* });
+* ```
+*/
+function extractContextFromRequest(request) {
+	const carrier = {};
+	const traceparent = request.headers.get("traceparent");
+	const tracestate = request.headers.get("tracestate");
+	const baggage = request.headers.get("baggage");
+	if (traceparent) carrier.traceparent = traceparent;
+	if (tracestate) carrier.tracestate = tracestate;
+	if (baggage) carrier.baggage = baggage;
+	if (Object.keys(carrier).length === 0) return ROOT_CONTEXT;
+	return propagation.extract(context.active(), carrier);
+}
+/**
+* Inject OpenTelemetry context into HTTP headers
+*
+* This function injects W3C Trace Context (traceparent, tracestate)
+* and Baggage into headers for outgoing requests.
+*
+* @param headers - Headers object to inject context into
+* @param ctx - Optional context to inject (defaults to active context)
+* @returns The headers object with injected trace context
+*
+* @example
+* ```typescript
+* const headers = new Headers();
+* injectContextToHeaders(headers);
+*
+* // Now use headers in outgoing fetch
+* await fetch('https://api.example.com', { headers });
+* ```
+*/
+function injectContextToHeaders(headers, ctx) {
+	const carrier = {};
+	propagation.inject(ctx ?? context.active(), carrier);
+	for (const [key, value] of Object.entries(carrier)) headers.set(key, value);
+	return headers;
+}
+/**
+* Create a new Headers object with injected trace context
+*
+* Convenience function that creates a new Headers object
+* with the current trace context already injected.
+*
+* @param existingHeaders - Optional existing headers to include
+* @param ctx - Optional context to inject (defaults to active context)
+* @returns New Headers object with trace context
+*
+* @example
+* ```typescript
+* const headers = createTracedHeaders({ 'Content-Type': 'application/json' });
+* await fetch('https://api.example.com', {
+*   method: 'POST',
+*   headers,
+*   body: JSON.stringify(data),
+* });
+* ```
+*/
+function createTracedHeaders(existingHeaders, ctx) {
+	return injectContextToHeaders(new Headers(existingHeaders), ctx);
+}
+/**
+* Run a function within a specific OpenTelemetry context
+*
+* This is a convenience wrapper around context.with() that
+* provides better TypeScript inference.
+*
+* @param parentContext - The context to run within
+* @param fn - The function to execute
+* @returns The result of the function
+*
+* @example
+* ```typescript
+* const parentContext = extractContextFromRequest(request);
+* const result = await runInContext(parentContext, async () => {
+*   return await processRequest();
+* });
+* ```
+*/
+function runInContext(parentContext, fn) {
+	return context.with(parentContext, fn);
+}
+/**
+* Get the current active context
+*
+* @returns The current active OpenTelemetry context
+*/
+function getActiveContext() {
+	return context.active();
+}
+
+//#endregion
+export { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext };
 //# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"context.js"}
+{"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\n  | Record<string, string>\n  | [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":";;;;;;;;;;;;;;;;;;;;;AAkCA,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/debug-headers.d.ts

@@ -1,20 +1,19 @@
-import { MiddlewareHandler } from './middleware.js';
-import './types-m5OjZJ-4.js';
-import '@opentelemetry/api';
+import { MiddlewareHandler } from "./middleware.js";
 
+//#region src/debug-headers.d.ts
 /**
  * Configuration for debug headers middleware
  */
 interface DebugHeadersConfig {
-    /**
-     * Whether to enable debug headers
-     * @default process.env.NODE_ENV === 'development'
-     */
-    enabled?: boolean;
-    /**
-     * Custom headers to add
-     */
-    customHeaders?: Record<string, string | (() => string)>;
+  /**
+   * Whether to enable debug headers
+   * @default process.env.NODE_ENV === 'development'
+   */
+  enabled?: boolean;
+  /**
+   * Custom headers to add
+   */
+  customHeaders?: Record<string, string | (() => string)>;
 }
 /**
  * Create middleware that adds debug headers to responses in development
@@ -39,5 +38,6 @@ interface DebugHeadersConfig {
  * ```
  */
 declare function debugHeadersMiddleware(config?: DebugHeadersConfig): MiddlewareHandler;
-
-export { type DebugHeadersConfig, debugHeadersMiddleware };
+//#endregion
+export { DebugHeadersConfig, debugHeadersMiddleware };
+//# sourceMappingURL=debug-headers.d.ts.map

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

@@ -0,0 +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"}