autotel-tanstack 1.1.0

package/dist/debug-headers.d.ts

@@ -0,0 +1,43 @@
+import { MiddlewareHandler } from './middleware.js';
+import './types-C37KSxMN.js';
+import '@opentelemetry/api';
+
+/**
+ * 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)>;
+}
+/**
+ * Create middleware that adds debug headers to responses in development
+ *
+ * Adds helpful debug information to response headers:
+ * - X-Debug-Timestamp: Request timestamp
+ * - X-Debug-Node-Version: Node.js version
+ * - X-Debug-Uptime: Process uptime in seconds
+ * - X-Debug-Trace-Id: Current trace ID (if available)
+ *
+ * @param config - Configuration options
+ * @returns Middleware handler
+ *
+ * @example
+ * ```typescript
+ * import { createStart } from '@tanstack/react-start';
+ * import { debugHeadersMiddleware } from 'autotel-tanstack/debug-headers';
+ *
+ * export const startInstance = createStart(() => ({
+ *   requestMiddleware: [debugHeadersMiddleware()],
+ * }));
+ * ```
+ */
+declare function debugHeadersMiddleware(config?: DebugHeadersConfig): MiddlewareHandler;
+
+export { type DebugHeadersConfig, debugHeadersMiddleware };

package/dist/debug-headers.js

@@ -0,0 +1,5 @@
+export { debugHeadersMiddleware } from './chunk-UTPW3QRT.js';
+import './chunk-EUYFVNYE.js';
+import './chunk-EGRHWZRV.js';
+//# sourceMappingURL=debug-headers.js.map
+//# sourceMappingURL=debug-headers.js.map

package/dist/debug-headers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"debug-headers.js"}

package/dist/error-reporting.d.ts

@@ -0,0 +1,118 @@
+import * as _tanstack_react_start from '@tanstack/react-start';
+
+/**
+ * Error reporting utilities for TanStack Start
+ *
+ * Provides basic error reporting without external dependencies,
+ * following the patterns from TanStack Start observability guide.
+ */
+/**
+ * Error report data structure
+ */
+interface ErrorReport {
+    id: string;
+    count: number;
+    lastSeen: Date;
+    error: {
+        name: string;
+        message: string;
+        stack?: string;
+        context?: unknown;
+    };
+}
+/**
+ * Error store for in-memory error tracking
+ *
+ * Stores error reports with deduplication by error name + message.
+ * Thread-safe for concurrent access.
+ */
+declare class ErrorStore {
+    private errors;
+    private readonly maxErrors;
+    /**
+     * Report an error
+     */
+    reportError(error: Error, context?: unknown): string;
+    /**
+     * Get all error reports
+     */
+    getAllErrors(): ErrorReport[];
+    /**
+     * Get a specific error by ID
+     */
+    getError(id: string): ErrorReport | undefined;
+    /**
+     * Clear all errors
+     */
+    clear(): void;
+    /**
+     * Clear a specific error
+     */
+    clearError(id: string): void;
+}
+/**
+ * Global error store instance
+ */
+declare const errorStore: ErrorStore;
+/**
+ * Report an error to the error store
+ *
+ * @example
+ * ```typescript
+ * import { reportError } from 'autotel-tanstack/error-reporting';
+ *
+ * try {
+ *   await riskyOperation();
+ * } catch (error) {
+ *   reportError(error as Error, {
+ *     userId: context.userId,
+ *     operation: 'riskyOperation',
+ *   });
+ *   throw error;
+ * }
+ * ```
+ */
+declare function reportError(error: Error, context?: unknown): string;
+/**
+ * Create an error reporting endpoint handler
+ *
+ * Returns a handler that exposes error reports in JSON format.
+ * Use this to create an `/admin/errors` endpoint.
+ *
+ * @example
+ * ```typescript
+ * // routes/admin/errors.ts
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { json } from '@tanstack/react-start';
+ * import { createErrorReportingHandler } from 'autotel-tanstack/error-reporting';
+ *
+ * export const Route = createFileRoute('/admin/errors')({
+ *   server: {
+ *     handlers: {
+ *       GET: createErrorReportingHandler(),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function createErrorReportingHandler(): () => Promise<_tanstack_react_start.JsonResponse<{
+    errors: ErrorReport[];
+}>>;
+/**
+ * Wrap a function with automatic error reporting
+ *
+ * Automatically reports errors to the error store.
+ *
+ * @example
+ * ```typescript
+ * import { withErrorReporting } from 'autotel-tanstack/error-reporting';
+ *
+ * const riskyOperation = createServerFn()
+ *   .handler(withErrorReporting(async () => {
+ *     return await performOperation();
+ *   }, { operation: 'riskyOperation' }));
+ * ```
+ */
+declare function withErrorReporting<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, context?: Record<string, unknown>): (...args: TArgs) => Promise<TReturn>;
+
+export { type ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting };

package/dist/error-reporting.js

@@ -0,0 +1,4 @@
+export { createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './chunk-XXBHZR3M.js';
+import './chunk-EGRHWZRV.js';
+//# sourceMappingURL=error-reporting.js.map
+//# sourceMappingURL=error-reporting.js.map

package/dist/error-reporting.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"error-reporting.js"}

package/dist/handlers.d.ts

@@ -0,0 +1,70 @@
+import { W as WrapStartHandlerConfig } from './types-C37KSxMN.js';
+import '@opentelemetry/api';
+
+/**
+ * Request handler type (compatible with TanStack Start handlers)
+ */
+type RequestHandler = (request: Request, opts?: {
+    context?: Record<string, unknown>;
+}) => Promise<Response> | Response;
+/**
+ * Wrap a TanStack Start handler with OpenTelemetry tracing
+ *
+ * This function wraps the entire request handler to automatically create
+ * spans for all incoming requests. It initializes OpenTelemetry and
+ * provides comprehensive request tracing.
+ *
+ * @param config - Configuration options including OTLP endpoint and headers
+ * @returns Function that wraps a request handler
+ *
+ * @example
+ * ```typescript
+ * // server.ts
+ * import { createStartHandler, defaultStreamHandler } from '@tanstack/react-start/server';
+ * import { wrapStartHandler } from 'autotel-tanstack/handlers';
+ *
+ * export default wrapStartHandler({
+ *   service: 'my-app',
+ *   endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+ *   headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY },
+ * })(createStartHandler(defaultStreamHandler));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With env var configuration (recommended for production)
+ * // Set OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS
+ * export default wrapStartHandler()(createStartHandler(defaultStreamHandler));
+ * ```
+ */
+declare function wrapStartHandler(config?: WrapStartHandlerConfig): (handler: RequestHandler) => RequestHandler;
+/**
+ * Create a traced handler without auto-initialization
+ *
+ * Use this when you want to initialize autotel separately
+ * (e.g., with more advanced configuration).
+ *
+ * @param config - Configuration options (excluding endpoint/headers)
+ * @returns Function that wraps a request handler
+ *
+ * @example
+ * ```typescript
+ * import { init } from 'autotel';
+ * import { createTracedHandler } from 'autotel-tanstack/handlers';
+ *
+ * // Initialize autotel with custom configuration
+ * init({
+ *   service: 'my-app',
+ *   endpoint: 'https://api.honeycomb.io',
+ *   instrumentations: [/* custom instrumentations *\/],
+ * });
+ *
+ * // Wrap handler without re-initializing
+ * export default createTracedHandler({
+ *   captureHeaders: ['x-request-id'],
+ * })(createStartHandler(defaultStreamHandler));
+ * ```
+ */
+declare function createTracedHandler(config?: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'>): (handler: RequestHandler) => RequestHandler;
+
+export { createTracedHandler, wrapStartHandler };

package/dist/handlers.js

@@ -0,0 +1,6 @@
+export { createTracedHandler, wrapStartHandler } from './chunk-Z5D2V4DU.js';
+import './chunk-I4LX3LOG.js';
+import './chunk-NTY64BKS.js';
+import './chunk-EGRHWZRV.js';
+//# sourceMappingURL=handlers.js.map
+//# sourceMappingURL=handlers.js.map

package/dist/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"handlers.js"}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { D as DEFAULT_CONFIG, S as SPAN_ATTRIBUTES, T as TanStackInstrumentationConfig, c as TraceLoaderConfig, b as TraceServerFnConfig, a as TracingMiddlewareConfig, W as WrapStartHandlerConfig } from './types-C37KSxMN.js';
+export { MiddlewareHandler, createTracingMiddleware, functionTracingMiddleware, tracingMiddleware } from './middleware.js';
+export { createTracedServerFnFactory, traceServerFn } from './server-functions.js';
+export { createTracedRoute, traceBeforeLoad, traceLoader } from './loaders.js';
+export { createTracedHandler, wrapStartHandler } from './handlers.js';
+export { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext } from './context.js';
+export { DebugHeadersConfig, debugHeadersMiddleware } from './debug-headers.js';
+export { TimingStats, createMetricsHandler, metricsCollector, recordTiming } from './metrics.js';
+export { ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './error-reporting.js';
+export { flush, init, shutdown, span, trace } from 'autotel';
+import '@opentelemetry/api';
+import '@tanstack/react-start';
+
+/**
+ * Environment detection utilities
+ * Prevents server-only code from running in the browser
+ */
+/**
+ * Check if we're running in a browser environment
+ * Uses typeof checks to avoid TypeScript DOM type requirements
+ */
+declare function isBrowser(): boolean;
+/**
+ * Check if we're running in a Node.js environment
+ */
+declare function isNode(): boolean;
+/**
+ * Check if we're in a server-side context
+ * In TanStack Start, middleware runs on the server, but router config
+ * might be evaluated on both sides during SSR
+ */
+declare function isServerSide(): boolean;
+
+export { isBrowser, isNode, isServerSide };

package/dist/index.js

@@ -0,0 +1,14 @@
+export { debugHeadersMiddleware } from './chunk-UTPW3QRT.js';
+export { createMetricsHandler, metricsCollector, recordTiming } from './chunk-JSI6QG7M.js';
+export { createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './chunk-XXBHZR3M.js';
+export { createTracingMiddleware, functionTracingMiddleware, tracingMiddleware } from './chunk-OLBHLVLE.js';
+export { createTracedServerFnFactory, traceServerFn } from './chunk-TNOQTZ3N.js';
+export { createTracedRoute, traceBeforeLoad, traceLoader } from './chunk-HKM7LMO6.js';
+export { isBrowser, isNode, isServerSide } from './chunk-EUYFVNYE.js';
+export { createTracedHandler, wrapStartHandler } from './chunk-Z5D2V4DU.js';
+export { DEFAULT_CONFIG, SPAN_ATTRIBUTES } from './chunk-I4LX3LOG.js';
+export { createTracedHeaders, extractContextFromRequest, getActiveContext, injectContextToHeaders, runInContext } from './chunk-NTY64BKS.js';
+import './chunk-EGRHWZRV.js';
+export { flush, init, shutdown, span, trace } from 'autotel';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/loaders.d.ts

@@ -0,0 +1,124 @@
+import { c as TraceLoaderConfig } from './types-C37KSxMN.js';
+import '@opentelemetry/api';
+
+/**
+ * Loader context type (compatible with TanStack router loader context)
+ */
+interface LoaderContext {
+    params?: Record<string, string>;
+    route?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Wrap a TanStack route loader with OpenTelemetry tracing
+ *
+ * This function wraps a loader function to automatically create spans
+ * for each invocation. It captures route ID, params (optionally),
+ * and errors.
+ *
+ * @param loaderFn - The loader function to wrap
+ * @param config - Configuration options
+ * @returns Wrapped loader function with tracing
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { traceLoader } from 'autotel-tanstack/loaders';
+ *
+ * export const Route = createFileRoute('/users/$userId')({
+ *   loader: traceLoader(async ({ params }) => {
+ *     return await db.users.findUnique({ where: { id: params.userId } });
+ *   }),
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom name and param capture
+ * export const Route = createFileRoute('/products/$category/$productId')({
+ *   loader: traceLoader(
+ *     async ({ params }) => {
+ *       return await db.products.findUnique({
+ *         where: { id: params.productId, category: params.category },
+ *       });
+ *     },
+ *     {
+ *       name: 'loadProduct',
+ *       captureParams: true,
+ *       captureResult: false,
+ *     }
+ *   ),
+ * });
+ * ```
+ */
+declare function traceLoader<T extends (context: LoaderContext) => Promise<unknown>>(loaderFn: T, config?: TraceLoaderConfig): T;
+/**
+ * Wrap a TanStack route beforeLoad function with OpenTelemetry tracing
+ *
+ * This function wraps a beforeLoad function to automatically create spans.
+ * beforeLoad runs before the route component renders and is typically
+ * used for auth checks, redirects, or data prefetching.
+ *
+ * @param beforeLoadFn - The beforeLoad function to wrap
+ * @param config - Configuration options
+ * @returns Wrapped beforeLoad function with tracing
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { traceBeforeLoad } from 'autotel-tanstack/loaders';
+ *
+ * export const Route = createFileRoute('/dashboard')({
+ *   beforeLoad: traceBeforeLoad(async ({ context }) => {
+ *     if (!context.auth.isAuthenticated) {
+ *       throw redirect({ to: '/login' });
+ *     }
+ *   }),
+ *   loader: async () => {
+ *     return await fetchDashboardData();
+ *   },
+ * });
+ * ```
+ */
+declare function traceBeforeLoad<T extends (context: LoaderContext) => Promise<unknown>>(beforeLoadFn: T, config?: TraceLoaderConfig): T;
+/**
+ * Create a traced route configuration helper
+ *
+ * This higher-order function helps create route configurations
+ * with automatic tracing for both loader and beforeLoad.
+ *
+ * @param routeId - The route identifier
+ * @param config - Tracing configuration
+ * @returns Object with traced loader and beforeLoad wrappers
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { createTracedRoute } from 'autotel-tanstack/loaders';
+ *
+ * const traced = createTracedRoute('/users/$userId');
+ *
+ * export const Route = createFileRoute('/users/$userId')({
+ *   beforeLoad: traced.beforeLoad(async ({ context }) => {
+ *     // Auth check
+ *   }),
+ *   loader: traced.loader(async ({ params }) => {
+ *     return await getUser(params.userId);
+ *   }),
+ * });
+ * ```
+ */
+declare function createTracedRoute(routeId: string, config?: Omit<TraceLoaderConfig, 'name'>): {
+    /**
+     * Wrap a loader function with tracing
+     */
+    loader<T extends (context: LoaderContext) => Promise<unknown>>(loaderFn: T): T;
+    /**
+     * Wrap a beforeLoad function with tracing
+     */
+    beforeLoad<T extends (context: LoaderContext) => Promise<unknown>>(beforeLoadFn: T): T;
+};
+
+export { createTracedRoute, traceBeforeLoad, traceLoader };

package/dist/loaders.js

@@ -0,0 +1,6 @@
+export { createTracedRoute, traceBeforeLoad, traceLoader } from './chunk-HKM7LMO6.js';
+import './chunk-EUYFVNYE.js';
+import './chunk-I4LX3LOG.js';
+import './chunk-EGRHWZRV.js';
+//# sourceMappingURL=loaders.js.map
+//# sourceMappingURL=loaders.js.map

package/dist/loaders.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"loaders.js"}

package/dist/metrics.d.ts

@@ -0,0 +1,113 @@
+import * as _tanstack_react_start from '@tanstack/react-start';
+
+/**
+ * Performance metrics collection for TanStack Start
+ *
+ * Provides utilities to collect and expose performance metrics
+ * following the patterns from TanStack Start observability guide.
+ */
+/**
+ * Performance timing data
+ */
+interface TimingStats {
+    count: number;
+    avg: number;
+    p50: number;
+    p95: number;
+    min: number;
+    max: number;
+}
+/**
+ * Metrics collector for performance data
+ *
+ * Collects timing metrics and provides statistical analysis.
+ * Thread-safe for concurrent access.
+ *
+ * @example
+ * ```typescript
+ * import { metricsCollector } from 'autotel-tanstack/metrics';
+ *
+ * // Record a timing
+ * metricsCollector.recordTiming('serverFn.getUser', 150);
+ *
+ * // Get stats
+ * const stats = metricsCollector.getStats('serverFn.getUser');
+ * console.log(`Average: ${stats.avg}ms, P95: ${stats.p95}ms`);
+ * ```
+ */
+declare class MetricsCollector {
+    private metrics;
+    private readonly maxSamples;
+    /**
+     * Record a timing measurement
+     */
+    recordTiming(name: string, duration: number): void;
+    /**
+     * Get statistics for a metric
+     */
+    getStats(name: string): TimingStats | null;
+    /**
+     * Get all collected metrics
+     */
+    getAllStats(): Record<string, TimingStats>;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+    /**
+     * Reset a specific metric
+     */
+    resetMetric(name: string): void;
+}
+/**
+ * Global metrics collector instance
+ */
+declare const metricsCollector: MetricsCollector;
+/**
+ * Helper to create a metrics endpoint handler
+ *
+ * Returns a handler that exposes metrics in JSON format.
+ * Use this to create a `/metrics` endpoint.
+ *
+ * @example
+ * ```typescript
+ * // routes/metrics.ts
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { json } from '@tanstack/react-start';
+ * import { createMetricsHandler } from 'autotel-tanstack/metrics';
+ *
+ * export const Route = createFileRoute('/metrics')({
+ *   server: {
+ *     handlers: {
+ *       GET: createMetricsHandler(),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function createMetricsHandler(): () => Promise<_tanstack_react_start.JsonResponse<{
+    system: {
+        uptime: number;
+        memory: NodeJS.MemoryUsage;
+        timestamp: string;
+    };
+    application: Record<string, TimingStats>;
+}>>;
+/**
+ * Auto-record timing from a function execution
+ *
+ * Wraps a function to automatically record its execution time.
+ *
+ * @example
+ * ```typescript
+ * import { recordTiming } from 'autotel-tanstack/metrics';
+ *
+ * const getUser = createServerFn({ method: 'GET' })
+ *   .handler(recordTiming('serverFn.getUser', async ({ data: id }) => {
+ *     return await db.users.findUnique({ where: { id } });
+ *   }));
+ * ```
+ */
+declare function recordTiming<T extends (...args: unknown[]) => Promise<unknown>>(metricName: string, fn: T): T;
+
+export { type TimingStats, createMetricsHandler, metricsCollector, recordTiming };

package/dist/metrics.js

@@ -0,0 +1,4 @@
+export { createMetricsHandler, metricsCollector, recordTiming } from './chunk-JSI6QG7M.js';
+import './chunk-EGRHWZRV.js';
+//# sourceMappingURL=metrics.js.map
+//# sourceMappingURL=metrics.js.map

package/dist/metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"metrics.js"}

package/dist/middleware.d.ts

@@ -0,0 +1,104 @@
+import { a as TracingMiddlewareConfig } from './types-C37KSxMN.js';
+import '@opentelemetry/api';
+
+/**
+ * Generic middleware handler type (compatible with TanStack's middleware pattern)
+ *
+ * This type represents the shape of TanStack middleware handlers.
+ * We use a generic type to avoid direct dependency on TanStack packages.
+ */
+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>;
+}
+/**
+ * Create a TanStack-compatible tracing middleware
+ *
+ * This creates middleware that automatically traces all requests/server functions
+ * with OpenTelemetry spans. Use with TanStack Start's middleware system.
+ *
+ * @param config - Configuration options
+ * @returns Middleware handler compatible with TanStack Start
+ *
+ * @example
+ * ```typescript
+ * // Global request middleware in app/start.ts
+ * import { createStart } from '@tanstack/react-start';
+ * import { createTracingMiddleware } from 'autotel-tanstack/middleware';
+ *
+ * export const startInstance = createStart(() => ({
+ *   requestMiddleware: [
+ *     createTracingMiddleware({
+ *       captureHeaders: ['x-request-id', 'user-agent'],
+ *       excludePaths: ['/health', '/metrics'],
+ *     }),
+ *   ],
+ * }));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server function middleware
+ * import { createServerFn } from '@tanstack/react-start';
+ * import { createTracingMiddleware } from 'autotel-tanstack/middleware';
+ *
+ * export const getUser = createServerFn({ method: 'GET' })
+ *   .middleware([createTracingMiddleware({ type: 'function' })])
+ *   .handler(async ({ data: id }) => {
+ *     return await db.users.findUnique({ where: { id } });
+ *   });
+ * ```
+ */
+declare function createTracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+/**
+ * Pre-configured tracing middleware with sensible defaults
+ *
+ * Convenience export for quick setup. Uses adaptive sampling,
+ * captures x-request-id header, and excludes common health check paths.
+ *
+ * @param config - Optional configuration overrides
+ * @returns Middleware handler
+ *
+ * @example
+ * ```typescript
+ * import { createStart } from '@tanstack/react-start';
+ * import { tracingMiddleware } from 'autotel-tanstack/middleware';
+ *
+ * export const startInstance = createStart(() => ({
+ *   requestMiddleware: [tracingMiddleware()],
+ * }));
+ * ```
+ */
+declare function tracingMiddleware<TContext = unknown>(config?: TracingMiddlewareConfig): MiddlewareHandler<TContext>;
+/**
+ * Create function-specific tracing middleware
+ *
+ * Convenience wrapper for server function middleware.
+ *
+ * @param config - Optional configuration
+ * @returns Middleware handler for server functions
+ *
+ * @example
+ * ```typescript
+ * import { createServerFn } from '@tanstack/react-start';
+ * import { functionTracingMiddleware } from 'autotel-tanstack/middleware';
+ *
+ * export const getUser = createServerFn({ method: 'GET' })
+ *   .middleware([functionTracingMiddleware()])
+ *   .handler(async ({ data: id }) => {
+ *     return await db.users.findUnique({ where: { id } });
+ *   });
+ * ```
+ */
+declare function functionTracingMiddleware<TContext = unknown>(config?: Omit<TracingMiddlewareConfig, 'type'>): MiddlewareHandler<TContext>;
+
+export { type MiddlewareHandler, createTracingMiddleware, functionTracingMiddleware, tracingMiddleware };