autotel-tanstack 1.14.5 → 2.0.0

package/README.md

@@ -146,24 +146,28 @@ export const sensitiveOperation = createServerFn({ method: 'POST' })
 
 ### Route Loaders
 
-Use `traceLoader` and `traceBeforeLoad` for route-level tracing:
+Use `traceLoader` and `traceBeforeLoad` for route-level tracing. Call them from inside the route's own `beforeLoad` / `loader`, passing the context through:
 
 ```typescript
 import { createFileRoute, redirect } from '@tanstack/react-router';
 import { traceLoader, traceBeforeLoad } from 'autotel-tanstack/loaders';
 
 export const Route = createFileRoute('/users/$userId')({
-  beforeLoad: traceBeforeLoad(async ({ context }) => {
-    if (!context.auth.isAuthenticated) {
-      throw redirect({ to: '/login' });
-    }
-  }),
-  loader: traceLoader(async ({ params }) => {
-    return await getUser(params.userId);
-  }),
+  beforeLoad: (ctx) =>
+    traceBeforeLoad(ctx, async ({ context }) => {
+      if (!context.auth.isAuthenticated) {
+        throw redirect({ to: '/login' });
+      }
+    }),
+  loader: (ctx) =>
+    traceLoader(ctx, async ({ params }) => {
+      return await getUser(params.userId);
+    }),
 });
 ```
 
+TanStack Router types each route's `beforeLoad` and `loader` from the function you write. Passing `ctx` through keeps that inference, so `params`, `search` and the context `beforeLoad` returns stay typed inside the traced function.
+
 ## Configuration
 
 ### createTracingServerHandler Options

package/dist/auto.d.ts

@@ -1,13 +1,13 @@
 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-CTK-UHdg.js";
+import { n as traceBeforeLoad, r as traceLoader } from "./loaders-CzjfY7s6.js";
 //#region src/auto.d.ts
 /** Check if auto-instrumentation is active. */
-declare function isAutoInstrumentationActive(): boolean;
+export declare function isAutoInstrumentationActive(): boolean;
 /** The configured service name. */
-declare function getServiceName(): string;
+export declare function getServiceName(): string;
 /** The configured OTLP endpoint, if any. */
-declare function getEndpoint(): string | undefined;
+export declare function getEndpoint(): string | undefined;
 //#endregion
-export { functionTracingMiddleware, getEndpoint, getServiceName, instrument, isAutoInstrumentationActive, traceBeforeLoad, traceLoader, traceServerFn, tracingMiddleware };
+export { functionTracingMiddleware, instrument, traceBeforeLoad, traceLoader, traceServerFn, tracingMiddleware };

package/dist/browser/context.d.ts

@@ -8,42 +8,41 @@
 /**
  * Type representing values that can be used to initialize Headers
  */
-type HeadersInitType = Headers | Record<string, string> | [string, string][];
+export type HeadersInitType = Headers | Record<string, string> | [string, string][];
 /**
  * Browser stub: Returns root context (no parent)
  */
-declare function extractContextFromRequest(_request: Request): unknown;
+export declare function extractContextFromRequest(_request: Request): unknown;
 /**
  * Browser stub: Returns headers unchanged
  */
-declare function injectContextToHeaders(headers: Headers, ctx?: unknown): Headers;
+export declare function injectContextToHeaders(headers: Headers, ctx?: unknown): Headers;
 /**
  * Browser stub: Create headers with optional initial values
  */
-declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: unknown): Headers;
+export declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: unknown): Headers;
 /**
  * Browser stub: Run function and return result
  */
-declare function runInContext<T>(parentContext: unknown, fn: () => T): T;
+export declare function runInContext<T>(parentContext: unknown, fn: () => T): T;
 /**
  * Browser stub: Returns empty context object
  */
-declare function getActiveContext(): unknown;
+export declare function getActiveContext(): unknown;
 /**
  * Browser stub: Returns empty string
  */
-declare function getTraceParent(): string;
+export declare function getTraceParent(): string;
 /**
  * Browser stub: Returns empty string
  */
-declare function getTraceState(): string;
+export declare function getTraceState(): string;
 /**
  * Browser stub: Returns undefined
  */
-declare function getCurrentTraceId(): string | undefined;
+export declare function getCurrentTraceId(): string | undefined;
 /**
  * Browser stub: Returns undefined
  */
-declare function getCurrentSpanId(): string | undefined;
-//#endregion
-export { HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext };
+export declare function getCurrentSpanId(): string | undefined;
+//#endregion

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

@@ -3,6 +3,5 @@ import { MiddlewareHandler } from "./middleware.js";
 /**
  * Browser stub: Returns pass-through middleware
  */
-declare function debugHeadersMiddleware<TContext = unknown>(): MiddlewareHandler<TContext>;
-//#endregion
-export { debugHeadersMiddleware };
+export declare function debugHeadersMiddleware<TContext = unknown>(): MiddlewareHandler<TContext>;
+//#endregion

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

@@ -8,7 +8,7 @@
 /**
  * Error entry structure (stub)
  */
-interface ErrorEntry {
+export interface ErrorEntry {
   timestamp: string;
   message: string;
   stack?: string;
@@ -17,22 +17,21 @@ interface ErrorEntry {
 /**
  * Browser stub: No-op
  */
-declare function reportError(error: Error, context?: Record<string, unknown>): void;
+export declare function reportError(error: Error, context?: Record<string, unknown>): void;
 /**
  * Browser stub: Returns empty array
  */
-declare function getRecentErrors(limit?: number): ErrorEntry[];
+export declare function getRecentErrors(limit?: number): ErrorEntry[];
 /**
  * Browser stub: No-op
  */
-declare function clearErrors(): void;
+export declare function clearErrors(): void;
 /**
  * Browser stub: Returns JSON Response with empty errors
  */
-declare function createErrorReportingHandler(): () => Response;
+export declare function createErrorReportingHandler(): () => Response;
 /**
  * Browser stub: Returns function unchanged
  */
-declare function withErrorReporting<T extends (...args: any[]) => any>(fn: T, context?: Record<string, unknown>): T;
-//#endregion
-export { ErrorEntry, clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting };
+export declare function withErrorReporting<T extends (...args: any[]) => any>(fn: T, context?: Record<string, unknown>): T;
+//#endregion

package/dist/browser/handlers.d.ts

@@ -1,12 +1,11 @@
-import { c as WrapStartHandlerConfig } from "../types-CrBF_-MC.js";
+import { c as WrapStartHandlerConfig } from "../types-CjDnjt3Q.js";
 //#region src/browser/handlers.d.ts
 /**
  * Handler type
  */
-type StartHandler<T = unknown> = (request: Request) => Promise<T>;
+export type StartHandler<T = unknown> = (request: Request) => Promise<T>;
 /**
  * Browser stub: Returns the handler unchanged
  */
-declare function wrapStartHandler<T>(config?: WrapStartHandlerConfig): (handler: StartHandler<T>) => StartHandler<T>;
-//#endregion
-export { StartHandler, wrapStartHandler };
+export declare function wrapStartHandler<T>(config?: WrapStartHandlerConfig): (handler: StartHandler<T>) => StartHandler<T>;
+//#endregion

package/dist/browser/index.d.ts

@@ -1,5 +1,5 @@
 import { HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext } from "./context.js";
-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-CrBF_-MC.js";
+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-CjDnjt3Q.js";
 import { MiddlewareHandler, createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from "./middleware.js";
 import { debugHeadersMiddleware } from "./debug-headers.js";
 import { ErrorEntry, clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting } from "./error-reporting.js";

package/dist/browser/loaders.d.ts

@@ -1,4 +1,4 @@
-import { a as TraceLoaderConfig } from "../types-CrBF_-MC.js";
+import { a as TraceLoaderConfig } from "../types-CjDnjt3Q.js";
 //#region src/browser/loaders.d.ts
 /**
  * Loader context type (compatible with TanStack router loader context)
@@ -11,19 +11,18 @@ interface LoaderContext {
   [key: string]: unknown;
 }
 /**
- * Browser stub: Returns the loader function unchanged
+ * Browser stub: Runs the loader logic untraced
  */
-declare function traceLoader<T extends (context: LoaderContext) => Promise<unknown>>(loaderFn: T, config?: TraceLoaderConfig): T;
+export declare function traceLoader<TContext extends LoaderContext, TResult>(context: TContext, loaderFn: (context: TContext) => TResult, config?: TraceLoaderConfig): TResult;
 /**
- * Browser stub: Returns the beforeLoad function unchanged
+ * Browser stub: Runs the beforeLoad logic untraced
  */
-declare function traceBeforeLoad<T extends (context: LoaderContext) => Promise<unknown>>(beforeLoadFn: T, config?: TraceLoaderConfig): T;
+export declare function traceBeforeLoad<TContext extends LoaderContext, TResult>(context: TContext, beforeLoadFn: (context: TContext) => TResult, config?: TraceLoaderConfig): TResult;
 /**
- * Browser stub: Returns object with pass-through wrappers
+ * Browser stub: Returns object with untraced runners
  */
-declare function createTracedRoute(routeId: string, config?: Omit<TraceLoaderConfig, 'name'>): {
-  loader<T extends (context: LoaderContext) => Promise<unknown>>(loaderFn: T): T;
-  beforeLoad<T extends (context: LoaderContext) => Promise<unknown>>(beforeLoadFn: T): T;
+export declare function createTracedRoute(routeId: string, config?: Omit<TraceLoaderConfig, 'name'>): {
+  loader<TContext extends LoaderContext, TResult>(context: TContext, loaderFn: (context: TContext) => TResult): TResult;
+  beforeLoad<TContext extends LoaderContext, TResult>(context: TContext, beforeLoadFn: (context: TContext) => TResult): TResult;
 };
-//#endregion
-export { createTracedRoute, traceBeforeLoad, traceLoader };
+//#endregion

package/dist/browser/loaders.js

@@ -1,26 +1,26 @@
 //#region src/browser/loaders.ts
 /**
-* Browser stub: Returns the loader function unchanged
+* Browser stub: Runs the loader logic untraced
 */
-function traceLoader(loaderFn, config) {
-	return loaderFn;
+function traceLoader(context, loaderFn, config) {
+	return loaderFn(context);
 }
 /**
-* Browser stub: Returns the beforeLoad function unchanged
+* Browser stub: Runs the beforeLoad logic untraced
 */
-function traceBeforeLoad(beforeLoadFn, config) {
-	return beforeLoadFn;
+function traceBeforeLoad(context, beforeLoadFn, config) {
+	return beforeLoadFn(context);
 }
 /**
-* Browser stub: Returns object with pass-through wrappers
+* Browser stub: Returns object with untraced runners
 */
 function createTracedRoute(routeId, config) {
 	return {
-		loader(loaderFn) {
-			return loaderFn;
+		loader(context, loaderFn) {
+			return loaderFn(context);
 		},
-		beforeLoad(beforeLoadFn) {
-			return beforeLoadFn;
+		beforeLoad(context, beforeLoadFn) {
+			return beforeLoadFn(context);
 		}
 	};
 }

package/dist/browser/metrics.d.ts

@@ -8,7 +8,7 @@
 /**
  * Metrics data structure (stub)
  */
-interface MetricsData {
+export interface MetricsData {
   requestCount: number;
   errorCount: number;
   avgLatency: number;
@@ -25,23 +25,23 @@ interface MetricsData {
 /**
  * Browser stub: Returns empty metrics
  */
-declare function getMetrics(): MetricsData;
+export declare function getMetrics(): MetricsData;
 /**
  * Browser stub: No-op
  */
-declare function recordTiming(name: string, durationMs: number): void;
+export declare function recordTiming(name: string, durationMs: number): void;
 /**
  * Browser stub: No-op
  */
-declare function recordError(name: string): void;
+export declare function recordError(name: string): void;
 /**
  * Browser stub: No-op
  */
-declare function resetMetrics(): void;
+export declare function resetMetrics(): void;
 /**
  * Browser stub: No-op metrics collector
  */
-declare const metricsCollector: {
+export declare const metricsCollector: {
   recordTiming: typeof recordTiming;
   recordError: typeof recordError;
   getMetrics: typeof getMetrics;
@@ -50,6 +50,5 @@ declare const metricsCollector: {
 /**
  * Browser stub: Returns JSON Response with empty metrics
  */
-declare function createMetricsHandler(): () => Response;
-//#endregion
-export { MetricsData, createMetricsHandler, getMetrics, metricsCollector, recordError, recordTiming, resetMetrics };
+export declare function createMetricsHandler(): () => Response;
+//#endregion

package/dist/browser/middleware.d.ts

@@ -1,9 +1,9 @@
-import { s as TracingMiddlewareConfig } from "../types-CrBF_-MC.js";
+import { s as TracingMiddlewareConfig } from "../types-CjDnjt3Q.js";
 //#region src/browser/middleware.d.ts
 /**
  * Generic middleware handler type
  */
-interface MiddlewareHandler<TContext = unknown> {
+export interface MiddlewareHandler<TContext = unknown> {
   (opts: {
     next: (ctx?: Partial<TContext>) => Promise<TContext>;
     context: TContext;
@@ -19,22 +19,21 @@ interface MiddlewareHandler<TContext = unknown> {
 /**
  * Browser stub: Returns pass-through middleware
  */
-declare function createTracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+export declare function createTracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
 /**
  * Browser stub: Returns pass-through middleware
  */
-declare function tracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+export 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>;
+export 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: {
+export 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 };
+//#endregion

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

@@ -1,12 +1,11 @@
-import { o as TraceServerFnConfig } from "../types-CrBF_-MC.js";
+import { o as TraceServerFnConfig } from "../types-CjDnjt3Q.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;
+export 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 };
+export declare function createTracedServerFnFactory<TCreateServerFn extends (...args: unknown[]) => unknown>(createServerFnOriginal: TCreateServerFn, defaultConfig?: Omit<TraceServerFnConfig, 'name'>): TCreateServerFn;
+//#endregion

package/dist/browser/testing.d.ts

@@ -8,7 +8,7 @@
 /**
  * Test span structure (stub)
  */
-interface TestSpan {
+export interface TestSpan {
   name: string;
   attributes: Record<string, unknown>;
   status: {
@@ -24,7 +24,7 @@ interface TestSpan {
 /**
  * Test collector structure (stub)
  */
-interface TestCollector {
+export interface TestCollector {
   getSpans(): TestSpan[];
   getSpansByName(name: string): TestSpan[];
   clear(): void;
@@ -33,22 +33,22 @@ interface TestCollector {
 /**
  * Browser stub: Returns empty collector
  */
-declare function createTestCollector(): TestCollector;
+export declare function createTestCollector(): TestCollector;
 /**
  * Browser stub: No-op
  */
-declare function assertSpanCreated(collector: TestCollector, name: string): void;
+export declare function assertSpanCreated(collector: TestCollector, name: string): void;
 /**
  * Browser stub: No-op
  */
-declare function assertSpanHasAttribute(collector: TestCollector, name: string, key: string, value?: unknown): void;
+export 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 = {
+export type SerializedSpan = {
   name: string;
   spanId: string;
   traceId: string;
@@ -71,7 +71,7 @@ type CreateFileRoute = (path: string) => (options: any) => any;
 /**
  * Browser stub: createTestSpansRoute is server-only.
  */
-declare function createTestSpansRoute(createFileRoute: CreateFileRoute, path?: string): unknown;
+export declare function createTestSpansRoute(createFileRoute: CreateFileRoute, path?: string): unknown;
 /** What createTestSpansHandlers() answers with. */
 interface CreateTestSpansHandlersResult {
   GET: (input: HandlerInput) => Response;
@@ -81,6 +81,5 @@ interface CreateTestSpansHandlersResult {
  * Browser stub: test-spans handlers are server-only.
  * Returns no-op handlers that always return 404.
  */
-declare function createTestSpansHandlers(): CreateTestSpansHandlersResult;
-//#endregion
-export { SerializedSpan, TestCollector, TestSpan, assertSpanCreated, assertSpanHasAttribute, createTestCollector, createTestSpansHandlers, createTestSpansRoute };
+export declare function createTestSpansHandlers(): CreateTestSpansHandlersResult;
+//#endregion

package/dist/browser/types.d.ts

@@ -1,2 +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-CrBF_-MC.js";
+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-CjDnjt3Q.js";
 export { Attributes, DEFAULT_CONFIG, SPAN_ATTRIBUTES, TanStackInstrumentationConfig, TraceLoaderConfig, TraceServerFnConfig, TracingMiddlewareConfig, WrapStartHandlerConfig };

package/dist/context.d.ts

@@ -4,7 +4,7 @@ import { Context } from "@opentelemetry/api";
  * Type representing values that can be used to initialize Headers
  * This is equivalent to the DOM's HeadersInit type but works in Node.js
  */
-type HeadersInitType = Headers | Record<string, string> | [string, string][];
+export type HeadersInitType = Headers | Record<string, string> | [string, string][];
 /**
  * Extract OpenTelemetry context from HTTP request headers
  *
@@ -25,7 +25,7 @@ type HeadersInitType = Headers | Record<string, string> | [string, string][];
  * });
  * ```
  */
-declare function extractContextFromRequest(request: Request): Context;
+export declare function extractContextFromRequest(request: Request): Context;
 /**
  * Inject OpenTelemetry context into HTTP headers
  *
@@ -45,7 +45,7 @@ declare function extractContextFromRequest(request: Request): Context;
  * await fetch('https://api.example.com', { headers });
  * ```
  */
-declare function injectContextToHeaders(headers: Headers, ctx?: Context): Headers;
+export declare function injectContextToHeaders(headers: Headers, ctx?: Context): Headers;
 /**
  * Create a new Headers object with injected trace context
  *
@@ -66,7 +66,7 @@ declare function injectContextToHeaders(headers: Headers, ctx?: Context): Header
  * });
  * ```
  */
-declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: Context): Headers;
+export declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: Context): Headers;
 /**
  * Run a function within a specific OpenTelemetry context
  *
@@ -85,25 +85,24 @@ declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: Co
  * });
  * ```
  */
-declare function runInContext<T>(parentContext: Context, fn: () => T): T;
+export declare function runInContext<T>(parentContext: Context, fn: () => T): T;
 /**
  * Get the current active context
  *
  * @returns The current active OpenTelemetry context
  */
-declare function getActiveContext(): Context;
+export declare function getActiveContext(): Context;
 /**
  * The `traceparent` header value for the active context, or `''` when there is
  * no active span. Use it to log the id you send downstream.
  */
-declare function getTraceParent(ctx?: Context): string;
+export declare function getTraceParent(ctx?: Context): string;
 /**
  * The `tracestate` header value for the active context, or `''` when unset.
  */
-declare function getTraceState(ctx?: Context): string;
+export declare function getTraceState(ctx?: Context): string;
 /** Trace id of the active span, or `undefined` outside a span. */
-declare function getCurrentTraceId(ctx?: Context): string | undefined;
+export declare function getCurrentTraceId(ctx?: Context): string | undefined;
 /** Span id of the active span, or `undefined` outside a span. */
-declare function getCurrentSpanId(ctx?: Context): string | undefined;
-//#endregion
-export { HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext };
+export declare function getCurrentSpanId(ctx?: Context): string | undefined;
+//#endregion

package/dist/debug-headers.d.ts

@@ -3,7 +3,7 @@ import { MiddlewareHandler } from "./middleware.js";
 /**
  * Configuration for debug headers middleware
  */
-interface DebugHeadersConfig {
+export interface DebugHeadersConfig {
   /**
    * Whether to enable debug headers
    * @default process.env.NODE_ENV === 'development'
@@ -36,6 +36,5 @@ interface DebugHeadersConfig {
  * }));
  * ```
  */
-declare function debugHeadersMiddleware(config?: DebugHeadersConfig): MiddlewareHandler;
-//#endregion
-export { DebugHeadersConfig, debugHeadersMiddleware };
+export declare function debugHeadersMiddleware(config?: DebugHeadersConfig): MiddlewareHandler;
+//#endregion

package/dist/debug-headers.js

@@ -1,4 +1,4 @@
-import { r as isServerSide } from "./env-BpFWNnpL.js";
+import { r as isServerSide } from "./env-rT3_WobG.js";
 
 //#region src/debug-headers.ts
 /**

package/dist/{env-BpFWNnpL.js → env-rT3_WobG.js}

@@ -8,13 +8,13 @@
 * Uses typeof checks to avoid TypeScript DOM type requirements
 */
 function isBrowser() {
-	return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+	return typeof globalThis !== "undefined" && globalThis.window !== void 0 && globalThis.document !== void 0;
 }
 /**
 * Check if we're running in a Node.js environment
 */
 function isNode() {
-	return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+	return typeof process !== "undefined" && process.versions !== void 0 && process.versions.node !== void 0;
 }
 /**
 * Check if we're in a server-side context

package/dist/error-reporting.d.ts

@@ -8,7 +8,7 @@
 /**
  * Error report data structure
  */
-interface ErrorReport {
+export interface ErrorReport {
   id: string;
   count: number;
   lastSeen: Date;
@@ -52,7 +52,7 @@ declare class ErrorStore {
 /**
  * Global error store instance
  */
-declare const errorStore: ErrorStore;
+export declare const errorStore: ErrorStore;
 /**
  * Report an error to the error store
  *
@@ -71,7 +71,7 @@ declare const errorStore: ErrorStore;
  * }
  * ```
  */
-declare function reportError(error: Error, context?: unknown): string;
+export declare function reportError(error: Error, context?: unknown): string;
 /**
  * Create an error reporting endpoint handler
  *
@@ -94,7 +94,7 @@ declare function reportError(error: Error, context?: unknown): string;
  * });
  * ```
  */
-declare function createErrorReportingHandler(): () => Promise<import("@tanstack/react-start").JsonResponse<{
+export declare function createErrorReportingHandler(): () => Promise<import("@tanstack/react-start").JsonResponse<{
   errors: ErrorReport[];
 }>>;
 /**
@@ -112,6 +112,5 @@ declare function createErrorReportingHandler(): () => Promise<import("@tanstack/
  *   }, { operation: 'riskyOperation' }));
  * ```
  */
-declare function withErrorReporting<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, context?: Record<string, unknown>): (...args: TArgs) => Promise<TReturn>;
-//#endregion
-export { ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting };
+export declare function withErrorReporting<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, context?: Record<string, unknown>): (...args: TArgs) => Promise<TReturn>;
+//#endregion

package/dist/handlers.d.ts

@@ -1,4 +1,4 @@
-import { s as WrapStartHandlerConfig } from "./types-BZNf5yHJ.js";
+import { s as WrapStartHandlerConfig } from "./types-DD1_xVG9.js";
 //#region src/handlers.d.ts
 /**
  * Request handler type (compatible with TanStack Start handlers)
@@ -36,7 +36,7 @@ type RequestHandler = (request: Request, opts?: {
  * export default wrapStartHandler()(createStartHandler(defaultStreamHandler));
  * ```
  */
-declare function wrapStartHandler(config?: WrapStartHandlerConfig): (handler: RequestHandler) => RequestHandler;
+export declare function wrapStartHandler(config?: WrapStartHandlerConfig): (handler: RequestHandler) => RequestHandler;
 /**
  * Create a traced handler without auto-initialization
  *
@@ -64,6 +64,5 @@ declare function wrapStartHandler(config?: WrapStartHandlerConfig): (handler: Re
  * })(createStartHandler(defaultStreamHandler));
  * ```
  */
-declare function createTracedHandler(config?: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'>): (handler: RequestHandler) => RequestHandler;
-//#endregion
-export { createTracedHandler, wrapStartHandler };
+export declare function createTracedHandler(config?: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'>): (handler: RequestHandler) => RequestHandler;
+//#endregion