autotel-tanstack 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Jag Reehal 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,294 @@
+# autotel-tanstack
+
+OpenTelemetry instrumentation for TanStack Start applications. Automatic tracing for server functions, middleware, and route loaders.
+
+## Features
+
+- **Zero-Config Option** - Just import `autotel-tanstack/auto` and you're done
+- **Framework-Aligned API** - Uses TanStack's middleware patterns
+- **Full Coverage** - Server functions, loaders, beforeLoad, HTTP requests
+- **Tree-Shakeable** - Only bundle what you use
+- **Type-Safe** - Full TypeScript support
+- **Vendor-Agnostic** - Works with any OTLP-compatible backend (Honeycomb, Datadog, Jaeger, etc.)
+
+## Installation
+
+```bash
+npm install autotel-tanstack autotel
+# or
+pnpm add autotel-tanstack autotel
+# or
+yarn add autotel-tanstack autotel
+```
+
+## Quick Start
+
+### Option 1: Zero-Config (Recommended)
+
+```typescript
+// app/start.ts (React) or app/start.ts (Solid)
+import 'autotel-tanstack/auto';
+import { createStart } from '@tanstack/react-start';
+
+// Set env vars: OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT
+export const startInstance = createStart(() => ({}));
+```
+
+### Option 2: Middleware-Based
+
+```typescript
+// app/start.ts
+import { createStart } from '@tanstack/react-start';
+import { tracingMiddleware } from 'autotel-tanstack/middleware';
+import { init } from 'autotel';
+
+// Initialize autotel
+init({
+  service: 'my-app',
+  endpoint: 'https://api.honeycomb.io',
+  headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY },
+});
+
+export const startInstance = createStart(() => ({
+  requestMiddleware: [tracingMiddleware()],
+}));
+```
+
+### Option 3: Handler Wrapper (Full Control)
+
+```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));
+```
+
+## Usage
+
+### Tracing Server Functions
+
+```typescript
+import { createServerFn } from '@tanstack/react-start';
+import { functionTracingMiddleware } from 'autotel-tanstack/middleware';
+
+// Using middleware (recommended)
+export const getUser = createServerFn({ method: 'GET' })
+  .middleware([functionTracingMiddleware()])
+  .handler(async ({ data: id }) => {
+    return await db.users.findUnique({ where: { id } });
+  });
+
+// Or using explicit wrapper
+import { traceServerFn } from 'autotel-tanstack/server-functions';
+
+const getUserBase = createServerFn({ method: 'GET' }).handler(
+  async ({ data: id }) => {
+    return await db.users.findUnique({ where: { id } });
+  },
+);
+
+export const getUser = traceServerFn(getUserBase, { name: 'getUser' });
+```
+
+### Tracing Route Loaders
+
+```typescript
+import { createFileRoute } 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);
+  }),
+});
+```
+
+### Using createTracedRoute Helper
+
+```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);
+  }),
+});
+```
+
+## Configuration
+
+### Middleware Configuration
+
+```typescript
+import { createTracingMiddleware } from 'autotel-tanstack/middleware';
+
+const middleware = createTracingMiddleware({
+  // Type: 'request' for global middleware, 'function' for server functions
+  type: 'request',
+
+  // Headers to capture as span attributes
+  captureHeaders: ['x-request-id', 'user-agent'],
+
+  // Whether to capture function arguments (default: true)
+  captureArgs: true,
+
+  // Whether to capture function results (default: false - PII concern)
+  captureResults: false,
+
+  // Paths to exclude from tracing
+  excludePaths: ['/health', '/metrics', '/api/internal/*'],
+
+  // Sampling strategy: 'always' | 'adaptive' | 'never'
+  sampling: 'adaptive',
+
+  // Custom attributes function
+  customAttributes: ({ type, name, request }) => ({
+    'custom.attribute': 'value',
+  }),
+});
+```
+
+### Handler Configuration
+
+```typescript
+import { wrapStartHandler } from 'autotel-tanstack/handlers';
+
+const handler = wrapStartHandler({
+  // Service name (default: OTEL_SERVICE_NAME or 'tanstack-start')
+  service: 'my-app',
+
+  // OTLP endpoint (default: OTEL_EXPORTER_OTLP_ENDPOINT)
+  endpoint: 'https://api.honeycomb.io',
+
+  // OTLP headers (default: parsed from OTEL_EXPORTER_OTLP_HEADERS)
+  headers: { 'x-honeycomb-team': 'YOUR_API_KEY' },
+
+  // All middleware config options also available
+  captureHeaders: ['x-request-id'],
+  excludePaths: ['/health'],
+});
+```
+
+## Environment Variables
+
+| Variable                      | Description                        | Example                     |
+| ----------------------------- | ---------------------------------- | --------------------------- |
+| `OTEL_SERVICE_NAME`           | Service name for spans             | `my-app`                    |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP collector URL                 | `https://api.honeycomb.io`  |
+| `OTEL_EXPORTER_OTLP_HEADERS`  | Auth headers (key=value,key=value) | `x-honeycomb-team=YOUR_KEY` |
+| `AUTOTEL_DEBUG`               | Enable debug logging               | `true`                      |
+
+## Span Attributes
+
+### HTTP Request Spans
+
+- `http.request.method` - GET, POST, etc.
+- `url.path` - Request path
+- `url.query` - Query string
+- `http.response.status_code` - Response status
+- `tanstack.request.duration_ms` - Request duration
+
+### Server Function Spans
+
+- `rpc.system` - "tanstack-start"
+- `rpc.method` - Function name
+- `tanstack.server_function.name` - Function name
+- `tanstack.server_function.method` - HTTP method
+- `tanstack.server_function.args` - Serialized arguments (if enabled)
+
+### Loader Spans
+
+- `tanstack.loader.route_id` - Route identifier
+- `tanstack.loader.type` - "loader" or "beforeLoad"
+- `tanstack.loader.params` - Route params (if enabled)
+
+## Testing
+
+```typescript
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import { createTestHarness } from 'autotel-tanstack/testing';
+
+describe('MyServerFunction', () => {
+  let harness: ReturnType<typeof createTestHarness>;
+
+  beforeEach(() => {
+    harness = createTestHarness();
+  });
+
+  afterEach(() => {
+    harness.reset();
+  });
+
+  it('should trace the server function', async () => {
+    await myServerFunction({ id: '123' });
+
+    harness.assertServerFnTraced('myServerFunction');
+    harness.assertSpanHasAttribute(
+      /tanstack\.serverFn/,
+      'tanstack.server_function.name',
+      'myServerFunction',
+    );
+  });
+});
+```
+
+### Mock Utilities
+
+```typescript
+import {
+  createMockRequest,
+  generateTraceparent,
+} from 'autotel-tanstack/testing';
+
+// Create mock request
+const request = createMockRequest('GET', '/api/users', {
+  headers: { 'x-request-id': 'test-123' },
+  traceparent: generateTraceparent(),
+});
+```
+
+## Context Propagation
+
+For distributed tracing across services:
+
+```typescript
+import {
+  createTracedHeaders,
+  extractContextFromRequest,
+} from 'autotel-tanstack/context';
+
+// Outgoing requests - inject trace context
+const headers = createTracedHeaders({ 'Content-Type': 'application/json' });
+await fetch('https://api.example.com', { headers, method: 'POST', body });
+
+// Incoming requests - extract parent context
+const parentContext = extractContextFromRequest(request);
+```
+
+## Supported Frameworks
+
+- **@tanstack/react-start** ^1.139.14
+- **@tanstack/solid-start** ^1.139.14
+
+## License
+
+MIT

package/dist/auto.d.ts

@@ -0,0 +1,44 @@
+export { functionTracingMiddleware, tracingMiddleware } from './middleware.js';
+export { traceServerFn } from './server-functions.js';
+export { traceBeforeLoad, traceLoader } from './loaders.js';
+import './types-C37KSxMN.js';
+import '@opentelemetry/api';
+
+/**
+ * Zero-config auto-instrumentation for TanStack Start
+ *
+ * Import this module to automatically instrument TanStack Start applications
+ * with OpenTelemetry tracing. Configuration is read from environment variables.
+ *
+ * Environment Variables:
+ * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')
+ * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL
+ * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers (key=value,key=value)
+ *
+ * @example
+ * ```typescript
+ * // app/start.ts
+ * import 'autotel-tanstack/auto';
+ * import { createStart } from '@tanstack/react-start';
+ *
+ * // Tracing is automatically configured!
+ * export const startInstance = createStart(() => ({}));
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * Check if auto-instrumentation is active
+ */
+declare function isAutoInstrumentationActive(): boolean;
+/**
+ * Get the configured service name
+ */
+declare function getServiceName(): string;
+/**
+ * Get the configured endpoint
+ */
+declare function getEndpoint(): string | undefined;
+
+export { getEndpoint, getServiceName, isAutoInstrumentationActive };

package/dist/auto.js

@@ -0,0 +1,47 @@
+export { functionTracingMiddleware, tracingMiddleware } from './chunk-OLBHLVLE.js';
+export { traceServerFn } from './chunk-TNOQTZ3N.js';
+export { traceBeforeLoad, traceLoader } from './chunk-HKM7LMO6.js';
+import './chunk-EUYFVNYE.js';
+import './chunk-I4LX3LOG.js';
+import './chunk-NTY64BKS.js';
+import './chunk-EGRHWZRV.js';
+import { init } from 'autotel';
+
+var service = process.env.OTEL_SERVICE_NAME || "tanstack-start";
+var endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+var headers;
+if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
+  headers = {};
+  const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(",");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=");
+    if (key && value) {
+      headers[key.trim()] = value.trim();
+    }
+  }
+}
+init({
+  service,
+  endpoint,
+  headers
+});
+if (process.env.NODE_ENV === "development" || process.env.AUTOTEL_DEBUG) {
+  console.log("[autotel-tanstack] Auto-initialized with:", {
+    service,
+    endpoint: endpoint || "(not configured)",
+    hasHeaders: !!headers
+  });
+}
+function isAutoInstrumentationActive() {
+  return true;
+}
+function getServiceName() {
+  return service;
+}
+function getEndpoint() {
+  return endpoint;
+}
+
+export { getEndpoint, getServiceName, isAutoInstrumentationActive };
+//# sourceMappingURL=auto.js.map
+//# sourceMappingURL=auto.js.map

package/dist/auto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auto.ts"],"names":[],"mappings":";;;;;;;;;AA2BA,IAAM,OAAA,GAAU,OAAA,CAAQ,GAAA,CAAI,iBAAA,IAAqB,gBAAA;AAGjD,IAAM,QAAA,GAAW,QAAQ,GAAA,CAAI,2BAAA;AAG7B,IAAI,OAAA;AACJ,IAAI,OAAA,CAAQ,IAAI,0BAAA,EAA4B;AAC1C,EAAA,OAAA,GAAU,EAAC;AACX,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,0BAAA,CAA2B,MAAM,GAAG,CAAA;AAC9D,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,MAAM,CAAC,GAAA,EAAK,KAAK,CAAA,GAAI,IAAA,CAAK,MAAM,GAAG,CAAA;AACnC,IAAA,IAAI,OAAO,KAAA,EAAO;AAChB,MAAA,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAM,CAAA,GAAI,MAAM,IAAA,EAAK;AAAA,IACnC;AAAA,EACF;AACF;AAGA,IAAA,CAAK;AAAA,EACH,OAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAC,CAAA;AAGD,IAAI,QAAQ,GAAA,CAAI,QAAA,KAAa,aAAA,IAAiB,OAAA,CAAQ,IAAI,aAAA,EAAe;AACvE,EAAA,OAAA,CAAQ,IAAI,2CAAA,EAA6C;AAAA,IACvD,OAAA;AAAA,IACA,UAAU,QAAA,IAAY,kBAAA;AAAA,IACtB,UAAA,EAAY,CAAC,CAAC;AAAA,GACf,CAAA;AACH;AAUO,SAAS,2BAAA,GAAuC;AACrD,EAAA,OAAO,IAAA;AACT;AAKO,SAAS,cAAA,GAAyB;AACvC,EAAA,OAAO,OAAA;AACT;AAKO,SAAS,WAAA,GAAkC;AAChD,EAAA,OAAO,QAAA;AACT","file":"auto.js","sourcesContent":["/**\n * Zero-config auto-instrumentation for TanStack Start\n *\n * Import this module to automatically instrument TanStack Start applications\n * with OpenTelemetry tracing. Configuration is read from environment variables.\n *\n * Environment Variables:\n * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')\n * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL\n * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers (key=value,key=value)\n *\n * @example\n * ```typescript\n * // app/start.ts\n * import 'autotel-tanstack/auto';\n * import { createStart } from '@tanstack/react-start';\n *\n * // Tracing is automatically configured!\n * export const startInstance = createStart(() => ({}));\n * ```\n *\n * @module\n */\n\nimport { init } from 'autotel';\n\n// Parse service name\nconst service = process.env.OTEL_SERVICE_NAME || 'tanstack-start';\n\n// Parse endpoint\nconst endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n\n// Parse headers\nlet headers: Record<string, string> | undefined;\nif (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 autotel\ninit({\n  service,\n  endpoint,\n  headers,\n});\n\n// Log initialization (only in development)\nif (process.env.NODE_ENV === 'development' || process.env.AUTOTEL_DEBUG) {\n  console.log('[autotel-tanstack] Auto-initialized with:', {\n    service,\n    endpoint: endpoint || '(not configured)',\n    hasHeaders: !!headers,\n  });\n}\n\n// Re-export middleware for convenience\nexport { tracingMiddleware, functionTracingMiddleware } from './middleware';\nexport { traceServerFn } from './server-functions';\nexport { traceLoader, traceBeforeLoad } from './loaders';\n\n/**\n * Check if auto-instrumentation is active\n */\nexport function isAutoInstrumentationActive(): boolean {\n  return true;\n}\n\n/**\n * Get the configured service name\n */\nexport function getServiceName(): string {\n  return service;\n}\n\n/**\n * Get the configured endpoint\n */\nexport function getEndpoint(): string | undefined {\n  return endpoint;\n}\n"]}

package/dist/browser/context.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Browser stub for context module
+ *
+ * In browser environments, context propagation is not needed.
+ * These functions return empty/default values.
+ */
+/**
+ * Type representing values that can be used to initialize Headers
+ */
+type HeadersInitType = Headers | Record<string, string> | [string, string][];
+/**
+ * Browser stub: Returns root context (no parent)
+ */
+declare function extractContextFromRequest(_request: Request): unknown;
+/**
+ * Browser stub: Returns headers unchanged
+ */
+declare function injectContextToHeaders(headers: Headers, ctx?: unknown): Headers;
+/**
+ * Browser stub: Create headers with optional initial values
+ */
+declare function createTracedHeaders(existingHeaders?: HeadersInitType, ctx?: unknown): Headers;
+/**
+ * Browser stub: Run function and return result
+ */
+declare function runInContext<T>(parentContext: unknown, fn: () => T): T;
+/**
+ * Browser stub: Returns empty context object
+ */
+declare function getActiveContext(): unknown;
+/**
+ * Browser stub: Returns empty string
+ */
+declare function getTraceParent(): string;
+/**
+ * Browser stub: Returns empty string
+ */
+declare function getTraceState(): string;
+/**
+ * Browser stub: Returns undefined
+ */
+declare function getCurrentTraceId(): string | undefined;
+/**
+ * Browser stub: Returns undefined
+ */
+declare function getCurrentSpanId(): string | undefined;
+
+export { type HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext };

package/dist/browser/context.js

@@ -0,0 +1,3 @@
+export { createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext } from '../chunk-DTZCOB4W.js';
+//# sourceMappingURL=context.js.map
+//# sourceMappingURL=context.js.map

package/dist/browser/context.js.map

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

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

@@ -0,0 +1,16 @@
+import { MiddlewareHandler } from './middleware.js';
+import './types.js';
+
+/**
+ * Browser stub for debug-headers module
+ *
+ * Debug headers are server-side only.
+ * In browser, this returns pass-through middleware.
+ */
+
+/**
+ * Browser stub: Returns pass-through middleware
+ */
+declare function debugHeadersMiddleware<TContext = unknown>(): MiddlewareHandler<TContext>;
+
+export { debugHeadersMiddleware };

package/dist/browser/debug-headers.js

@@ -0,0 +1,3 @@
+export { debugHeadersMiddleware } from '../chunk-JXO7H6KO.js';
+//# sourceMappingURL=debug-headers.js.map
+//# sourceMappingURL=debug-headers.js.map

package/dist/browser/debug-headers.js.map

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

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

@@ -0,0 +1,37 @@
+/**
+ * Browser stub for error-reporting module
+ *
+ * Error reporting/collection only happens on the server.
+ * In browser, these are no-op functions.
+ */
+/**
+ * Error entry structure (stub)
+ */
+interface ErrorEntry {
+    timestamp: string;
+    message: string;
+    stack?: string;
+    context?: Record<string, unknown>;
+}
+/**
+ * Browser stub: No-op
+ */
+declare function reportError(error: Error, context?: Record<string, unknown>): void;
+/**
+ * Browser stub: Returns empty array
+ */
+declare function getRecentErrors(limit?: number): ErrorEntry[];
+/**
+ * Browser stub: No-op
+ */
+declare function clearErrors(): void;
+/**
+ * Browser stub: Returns JSON Response with empty errors
+ */
+declare function createErrorReportingHandler(): () => Response;
+/**
+ * Browser stub: Returns function unchanged
+ */
+declare function withErrorReporting<T extends (...args: unknown[]) => unknown>(fn: T, context?: Record<string, unknown>): T;
+
+export { type ErrorEntry, clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting };

package/dist/browser/error-reporting.js

@@ -0,0 +1,3 @@
+export { clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting } from '../chunk-HIQYW2HB.js';
+//# sourceMappingURL=error-reporting.js.map
+//# sourceMappingURL=error-reporting.js.map

package/dist/browser/error-reporting.js.map

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

package/dist/browser/handlers.d.ts

@@ -0,0 +1,19 @@
+import { WrapStartHandlerConfig } from './types.js';
+
+/**
+ * Browser stub for handlers module
+ *
+ * Handler wrapping only applies on the server side.
+ * In browser, we just return the handler unchanged.
+ */
+
+/**
+ * Handler type
+ */
+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>;
+
+export { type StartHandler, wrapStartHandler };

package/dist/browser/handlers.js

@@ -0,0 +1,3 @@
+export { wrapStartHandler } from '../chunk-V3RO5N2M.js';
+//# sourceMappingURL=handlers.js.map
+//# sourceMappingURL=handlers.js.map

package/dist/browser/handlers.js.map

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

package/dist/browser/index.d.ts

@@ -0,0 +1,10 @@
+export { Attributes, DEFAULT_CONFIG, SPAN_ATTRIBUTES, TanStackInstrumentationConfig, TraceLoaderConfig, TraceServerFnConfig, TracingMiddlewareConfig, WrapStartHandlerConfig } from './types.js';
+export { createTracedRoute, traceBeforeLoad, traceLoader } from './loaders.js';
+export { createTracedServerFnFactory, traceServerFn } from './server-functions.js';
+export { MiddlewareHandler, createTracingMiddleware, functionTracingMiddleware, tracingMiddleware } from './middleware.js';
+export { HeadersInitType, createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext } from './context.js';
+export { StartHandler, wrapStartHandler } from './handlers.js';
+export { MetricsData, createMetricsHandler, getMetrics, metricsCollector, recordError, recordTiming, resetMetrics } from './metrics.js';
+export { ErrorEntry, clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting } from './error-reporting.js';
+export { debugHeadersMiddleware } from './debug-headers.js';
+export { TestCollector, TestSpan, assertSpanCreated, assertSpanHasAttribute, createTestCollector } from './testing.js';

package/dist/browser/index.js

@@ -0,0 +1,12 @@
+export { createMetricsHandler, getMetrics, metricsCollector, recordError, recordTiming, resetMetrics } from '../chunk-UMEJU65Q.js';
+export { clearErrors, createErrorReportingHandler, getRecentErrors, reportError, withErrorReporting } from '../chunk-HIQYW2HB.js';
+export { DEFAULT_CONFIG, SPAN_ATTRIBUTES } from '../chunk-MFYOV2SF.js';
+export { createTracingMiddleware, functionTracingMiddleware, tracingMiddleware } from '../chunk-4C7T5ZIM.js';
+export { createTracedServerFnFactory, traceServerFn } from '../chunk-CSFIPJC2.js';
+export { createTracedRoute, traceBeforeLoad, traceLoader } from '../chunk-MNP65ZX7.js';
+export { createTracedHeaders, extractContextFromRequest, getActiveContext, getCurrentSpanId, getCurrentTraceId, getTraceParent, getTraceState, injectContextToHeaders, runInContext } from '../chunk-DTZCOB4W.js';
+export { wrapStartHandler } from '../chunk-V3RO5N2M.js';
+export { assertSpanCreated, assertSpanHasAttribute, createTestCollector } from '../chunk-Z3MJ3GZ6.js';
+export { debugHeadersMiddleware } from '../chunk-JXO7H6KO.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

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

package/dist/browser/loaders.d.ts

@@ -0,0 +1,36 @@
+import { TraceLoaderConfig } from './types.js';
+
+/**
+ * Browser stub for loaders module
+ *
+ * In browser environments, these functions are no-ops that just call the
+ * original functions without any tracing overhead.
+ */
+
+/**
+ * Loader context type (compatible with TanStack router loader context)
+ */
+interface LoaderContext {
+    params?: Record<string, string>;
+    route?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Browser stub: Returns the loader function unchanged
+ */
+declare function traceLoader<T extends (context: LoaderContext) => Promise<unknown>>(loaderFn: T, config?: TraceLoaderConfig): T;
+/**
+ * Browser stub: Returns the beforeLoad function unchanged
+ */
+declare function traceBeforeLoad<T extends (context: LoaderContext) => Promise<unknown>>(beforeLoadFn: T, config?: TraceLoaderConfig): T;
+/**
+ * Browser stub: Returns object with pass-through wrappers
+ */
+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 { createTracedRoute, traceBeforeLoad, traceLoader };

package/dist/browser/loaders.js

@@ -0,0 +1,3 @@
+export { createTracedRoute, traceBeforeLoad, traceLoader } from '../chunk-MNP65ZX7.js';
+//# sourceMappingURL=loaders.js.map
+//# sourceMappingURL=loaders.js.map

package/dist/browser/loaders.js.map

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