autotel-tanstack 1.13.30 → 1.13.32

package/dist/debug-headers.js

@@ -1,5 +1,63 @@
-export { debugHeadersMiddleware } from './chunk-UTPW3QRT.js';
-import './chunk-EUYFVNYE.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=debug-headers.js.map
+import { r as isServerSide } from "./env-BpFWNnpL.js";
+
+//#region src/debug-headers.ts
+/**
+* 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()],
+* }));
+* ```
+*/
+function debugHeadersMiddleware(config = {}) {
+	if (!isServerSide()) return async function debugHeadersHandler(opts) {
+		return opts.next();
+	};
+	const enabled = config.enabled ?? (typeof process !== "undefined" && process.env.NODE_ENV === "development");
+	return async function debugHeadersHandler(opts) {
+		const { next, request } = opts;
+		if (!enabled || !request) return next();
+		const result = await next();
+		if (!(result instanceof Response)) return result;
+		const response = result;
+		const newHeaders = new Headers(response.headers);
+		newHeaders.set("X-Debug-Timestamp", (/* @__PURE__ */ new Date()).toISOString());
+		newHeaders.set("X-Debug-Node-Version", process.version);
+		newHeaders.set("X-Debug-Uptime", Math.floor(process.uptime()).toString());
+		try {
+			const { trace } = await import("@opentelemetry/api");
+			const activeSpan = trace.getActiveSpan();
+			if (activeSpan) {
+				const spanContext = activeSpan.spanContext();
+				if (spanContext.traceId) newHeaders.set("X-Debug-Trace-Id", spanContext.traceId);
+			}
+		} catch {}
+		if (config.customHeaders) for (const [key, value] of Object.entries(config.customHeaders)) {
+			const headerValue = typeof value === "function" ? value() : value;
+			newHeaders.set(`X-Debug-${key}`, headerValue);
+		}
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: newHeaders
+		});
+	};
+}
+
+//#endregion
+export { debugHeadersMiddleware };
 //# sourceMappingURL=debug-headers.js.map

package/dist/debug-headers.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"debug-headers.js"}
+{"version":3,"file":"debug-headers.js","names":[],"sources":["../src/debug-headers.ts"],"sourcesContent":["import { isServerSide } from './env';\nimport type { MiddlewareHandler } from './middleware';\n\n/**\n * Configuration for debug headers middleware\n */\nexport interface DebugHeadersConfig {\n  /**\n   * Whether to enable debug headers\n   * @default process.env.NODE_ENV === 'development'\n   */\n  enabled?: boolean;\n\n  /**\n   * Custom headers to add\n   */\n  customHeaders?: Record<string, string | (() => string)>;\n}\n\n/**\n * Create middleware that adds debug headers to responses in development\n *\n * Adds helpful debug information to response headers:\n * - X-Debug-Timestamp: Request timestamp\n * - X-Debug-Node-Version: Node.js version\n * - X-Debug-Uptime: Process uptime in seconds\n * - X-Debug-Trace-Id: Current trace ID (if available)\n *\n * @param config - Configuration options\n * @returns Middleware handler\n *\n * @example\n * ```typescript\n * import { createStart } from '@tanstack/react-start';\n * import { debugHeadersMiddleware } from 'autotel-tanstack/debug-headers';\n *\n * export const startInstance = createStart(() => ({\n *   requestMiddleware: [debugHeadersMiddleware()],\n * }));\n * ```\n */\nexport function debugHeadersMiddleware(\n  config: DebugHeadersConfig = {},\n): MiddlewareHandler {\n  // If we're in the browser, return a no-op middleware\n  if (!isServerSide()) {\n    return async function debugHeadersHandler(opts) {\n      return opts.next();\n    };\n  }\n\n  const enabled =\n    config.enabled ??\n    (typeof process !== 'undefined' && process.env.NODE_ENV === 'development');\n\n  return async function debugHeadersHandler(opts) {\n    const { next, request } = opts;\n\n    if (!enabled || !request) {\n      return next();\n    }\n\n    const result = await next();\n\n    // Check if result is a Response\n    if (!(result instanceof Response)) {\n      return result;\n    }\n\n    const response = result;\n\n    // Clone response to add headers (responses are immutable)\n    const newHeaders = new Headers(response.headers);\n\n    // Add standard debug headers\n    newHeaders.set('X-Debug-Timestamp', new Date().toISOString());\n    newHeaders.set('X-Debug-Node-Version', process.version);\n    newHeaders.set('X-Debug-Uptime', Math.floor(process.uptime()).toString());\n\n    // Add trace ID if available\n    try {\n      const { trace } = await import('@opentelemetry/api');\n      const activeSpan = trace.getActiveSpan();\n      if (activeSpan) {\n        const spanContext = activeSpan.spanContext();\n        if (spanContext.traceId) {\n          newHeaders.set('X-Debug-Trace-Id', spanContext.traceId);\n        }\n      }\n    } catch {\n      // OpenTelemetry not available, skip trace ID\n    }\n\n    // Add custom headers\n    if (config.customHeaders) {\n      for (const [key, value] of Object.entries(config.customHeaders)) {\n        const headerValue = typeof value === 'function' ? value() : value;\n        newHeaders.set(`X-Debug-${key}`, headerValue);\n      }\n    }\n\n    // Return new response with debug headers\n    return new Response(response.body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers: newHeaders,\n    });\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,uBACd,SAA6B,CAAC,GACX;CAEnB,IAAI,CAAC,aAAa,GAChB,OAAO,eAAe,oBAAoB,MAAM;EAC9C,OAAO,KAAK,KAAK;CACnB;CAGF,MAAM,UACJ,OAAO,YACN,OAAO,YAAY,eAAe,QAAQ,IAAI,aAAa;CAE9D,OAAO,eAAe,oBAAoB,MAAM;EAC9C,MAAM,EAAE,MAAM,YAAY;EAE1B,IAAI,CAAC,WAAW,CAAC,SACf,OAAO,KAAK;EAGd,MAAM,SAAS,MAAM,KAAK;EAG1B,IAAI,EAAE,kBAAkB,WACtB,OAAO;EAGT,MAAM,WAAW;EAGjB,MAAM,aAAa,IAAI,QAAQ,SAAS,OAAO;EAG/C,WAAW,IAAI,sCAAqB,IAAI,KAAK,EAAC,CAAC,YAAY,CAAC;EAC5D,WAAW,IAAI,wBAAwB,QAAQ,OAAO;EACtD,WAAW,IAAI,kBAAkB,KAAK,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;EAGxE,IAAI;GACF,MAAM,EAAE,UAAU,MAAM,OAAO;GAC/B,MAAM,aAAa,MAAM,cAAc;GACvC,IAAI,YAAY;IACd,MAAM,cAAc,WAAW,YAAY;IAC3C,IAAI,YAAY,SACd,WAAW,IAAI,oBAAoB,YAAY,OAAO;GAE1D;EACF,QAAQ,CAER;EAGA,IAAI,OAAO,eACT,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,aAAa,GAAG;GAC/D,MAAM,cAAc,OAAO,UAAU,aAAa,MAAM,IAAI;GAC5D,WAAW,IAAI,WAAW,OAAO,WAAW;EAC9C;EAIF,OAAO,IAAI,SAAS,SAAS,MAAM;GACjC,QAAQ,SAAS;GACjB,YAAY,SAAS;GACrB,SAAS;EACX,CAAC;CACH;AACF"}

package/dist/env-BpFWNnpL.js

@@ -0,0 +1,30 @@
+//#region src/env.ts
+/**
+* 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
+*/
+function isBrowser() {
+	return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+}
+/**
+* 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";
+}
+/**
+* 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
+*/
+function isServerSide() {
+	return isNode() && !isBrowser();
+}
+
+//#endregion
+export { isNode as n, isServerSide as r, isBrowser as t };
+//# sourceMappingURL=env-BpFWNnpL.js.map

package/dist/env-BpFWNnpL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-BpFWNnpL.js","names":[],"sources":["../src/env.ts"],"sourcesContent":["/**\n * Environment detection utilities\n * Prevents server-only code from running in the browser\n */\n\n/**\n * Check if we're running in a browser environment\n * Uses typeof checks to avoid TypeScript DOM type requirements\n */\nexport function isBrowser(): boolean {\n  return (\n    typeof globalThis !== 'undefined' &&\n    // @ts-expect-error - window may not exist in Node.js, that's the point\n    typeof globalThis.window !== 'undefined' &&\n    // @ts-expect-error - document may not exist in Node.js, that's the point\n    typeof globalThis.document !== 'undefined'\n  );\n}\n\n/**\n * Check if we're running in a Node.js environment\n */\nexport function isNode(): boolean {\n  return (\n    typeof process !== 'undefined' &&\n    typeof process.versions !== 'undefined' &&\n    typeof process.versions.node !== 'undefined'\n  );\n}\n\n/**\n * Check if we're in a server-side context\n * In TanStack Start, middleware runs on the server, but router config\n * might be evaluated on both sides during SSR\n */\nexport function isServerSide(): boolean {\n  // In TanStack Start, if we're in a request handler context, we're on the server\n  // Check for Node.js environment (server) and not browser\n  return isNode() && !isBrowser();\n}\n\n/**\n * Safely check if a module is available (for optional dependencies)\n */\nexport function isModuleAvailable(moduleName: string): boolean {\n  try {\n    // This will only work in Node.js, not browser\n    if (typeof require !== 'undefined') {\n      require.resolve(moduleName);\n      return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,YAAqB;CACnC,OACE,OAAO,eAAe,eAEtB,OAAO,WAAW,WAAW,eAE7B,OAAO,WAAW,aAAa;AAEnC;;;;AAKA,SAAgB,SAAkB;CAChC,OACE,OAAO,YAAY,eACnB,OAAO,QAAQ,aAAa,eAC5B,OAAO,QAAQ,SAAS,SAAS;AAErC;;;;;;AAOA,SAAgB,eAAwB;CAGtC,OAAO,OAAO,KAAK,CAAC,UAAU;AAChC"}

package/dist/error-reporting.d.ts

@@ -1,5 +1,4 @@
-import * as _tanstack_react_start from '@tanstack/react-start';
-
+//#region src/error-reporting.d.ts
 /**
  * Error reporting utilities for TanStack Start
  *
@@ -10,15 +9,15 @@ import * as _tanstack_react_start from '@tanstack/react-start';
  * Error report data structure
  */
 interface ErrorReport {
-    id: string;
-    count: number;
-    lastSeen: Date;
-    error: {
-        name: string;
-        message: string;
-        stack?: string;
-        context?: unknown;
-    };
+  id: string;
+  count: number;
+  lastSeen: Date;
+  error: {
+    name: string;
+    message: string;
+    stack?: string;
+    context?: unknown;
+  };
 }
 /**
  * Error store for in-memory error tracking
@@ -27,28 +26,28 @@ interface ErrorReport {
  * 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;
+  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
@@ -95,8 +94,8 @@ declare function reportError(error: Error, context?: unknown): string;
  * });
  * ```
  */
-declare function createErrorReportingHandler(): () => Promise<_tanstack_react_start.JsonResponse<{
-    errors: ErrorReport[];
+declare function createErrorReportingHandler(): () => Promise<import("@tanstack/react-start").JsonResponse<{
+  errors: ErrorReport[];
 }>>;
 /**
  * Wrap a function with automatic error reporting
@@ -114,5 +113,6 @@ declare function createErrorReportingHandler(): () => Promise<_tanstack_react_st
  * ```
  */
 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 };
+//#endregion
+export { ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting };
+//# sourceMappingURL=error-reporting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-reporting.d.ts","names":[],"sources":["../src/error-reporting.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,WAAA;EACf,EAAA;EACA,KAAA;EACA,QAAA,EAAU,IAAI;EACd,KAAA;IACE,IAAA;IACA,OAAA;IACA,KAAA;IACA,OAAA;EAAA;AAAA;;;;;;;cAUE,UAAA;EAAA,QACI,MAAA;EAAA,iBACS,SAAA;EAKS;;;EAA1B,WAAA,CAAY,KAAA,EAAO,KAAA,EAAO,OAAA;EA+DjB;;;EAPT,YAAA,IAAgB,WAAA;EAqBL;;AAAU;EAdrB,QAAA,CAAS,EAAA,WAAa,WAAA;EAsBkB;;;EAfxC,KAAA;EAmCc;;;EA5Bd,UAAA,CAAW,EAAA;AAAA;;;;cAQA,UAAA,EAAU,UAAmB;AA8C1C;;;;;;;;;;AAyBA;;;;;;;;AAzBA,iBA1BgB,WAAA,CAAY,KAAA,EAAO,KAAK,EAAE,OAAA;;;;;;;;;;;;;;;;;;AAsDJ;;;;;iBA5BtB,2BAAA,UAA2B,OAAA,iCAAA,YAAA;UAAA,WAAA;AAAA;;;;;;;;;;;;;;;;iBAyB3B,kBAAA,mCACd,EAAA,MAAQ,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,GAChC,OAAA,GAAU,MAAA,wBACL,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA"}

package/dist/error-reporting.js

@@ -1,4 +1,155 @@
-export { createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './chunk-XXBHZR3M.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=error-reporting.js.map
+//#region src/error-reporting.ts
+/**
+* Error store for in-memory error tracking
+*
+* Stores error reports with deduplication by error name + message.
+* Thread-safe for concurrent access.
+*/
+var ErrorStore = class {
+	errors = /* @__PURE__ */ new Map();
+	maxErrors = 100;
+	/**
+	* Report an error
+	*/
+	reportError(error, context) {
+		const key = `${error.name}:${error.message}`;
+		const existing = this.errors.get(key);
+		if (existing) {
+			existing.count++;
+			existing.lastSeen = /* @__PURE__ */ new Date();
+			if (context) existing.error.context = {
+				...existing.error.context,
+				...context
+			};
+			return key;
+		}
+		const report = {
+			id: key,
+			count: 1,
+			lastSeen: /* @__PURE__ */ new Date(),
+			error: {
+				name: error.name,
+				message: error.message,
+				stack: error.stack,
+				context
+			}
+		};
+		this.errors.set(key, report);
+		if (this.errors.size > this.maxErrors) {
+			const oldest = [...this.errors.entries()].toSorted((a, b) => a[1].lastSeen.getTime() - b[1].lastSeen.getTime())[0];
+			this.errors.delete(oldest[0]);
+		}
+		console.error("[ERROR REPORTED]:", {
+			error: error.message,
+			count: 1,
+			context
+		});
+		return key;
+	}
+	/**
+	* Get all error reports
+	*/
+	getAllErrors() {
+		return [...this.errors.values()];
+	}
+	/**
+	* Get a specific error by ID
+	*/
+	getError(id) {
+		return this.errors.get(id);
+	}
+	/**
+	* Clear all errors
+	*/
+	clear() {
+		this.errors.clear();
+	}
+	/**
+	* Clear a specific error
+	*/
+	clearError(id) {
+		this.errors.delete(id);
+	}
+};
+/**
+* Global error store instance
+*/
+const errorStore = new 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;
+* }
+* ```
+*/
+function reportError(error, context) {
+	return errorStore.reportError(error, context);
+}
+/**
+* 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(),
+*     },
+*   },
+* });
+* ```
+*/
+function createErrorReportingHandler() {
+	return async () => {
+		const { json } = await import("@tanstack/react-start");
+		return json({ errors: errorStore.getAllErrors() });
+	};
+}
+/**
+* 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' }));
+* ```
+*/
+function withErrorReporting(fn, context) {
+	return async (...args) => {
+		try {
+			return await fn(...args);
+		} catch (error) {
+			reportError(error, context);
+			throw error;
+		}
+	};
+}
+
+//#endregion
+export { createErrorReportingHandler, errorStore, reportError, withErrorReporting };
 //# sourceMappingURL=error-reporting.js.map

package/dist/error-reporting.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"error-reporting.js"}
+{"version":3,"file":"error-reporting.js","names":[],"sources":["../src/error-reporting.ts"],"sourcesContent":["/**\n * Error reporting utilities for TanStack Start\n *\n * Provides basic error reporting without external dependencies,\n * following the patterns from TanStack Start observability guide.\n */\n\n/**\n * Error report data structure\n */\nexport interface ErrorReport {\n  id: string;\n  count: number;\n  lastSeen: Date;\n  error: {\n    name: string;\n    message: string;\n    stack?: string;\n    context?: unknown;\n  };\n}\n\n/**\n * Error store for in-memory error tracking\n *\n * Stores error reports with deduplication by error name + message.\n * Thread-safe for concurrent access.\n */\nclass ErrorStore {\n  private errors = new Map<string, ErrorReport>();\n  private readonly maxErrors = 100; // Limit memory usage\n\n  /**\n   * Report an error\n   */\n  reportError(error: Error, context?: unknown): string {\n    const key = `${error.name}:${error.message}`;\n    const existing = this.errors.get(key);\n\n    if (existing) {\n      existing.count++;\n      existing.lastSeen = new Date();\n      if (context) {\n        // Merge context\n        existing.error.context = {\n          ...(existing.error.context as Record<string, unknown>),\n          ...(context as Record<string, unknown>),\n        };\n      }\n      return key;\n    }\n\n    // Add new error\n    const report: ErrorReport = {\n      id: key,\n      count: 1,\n      lastSeen: new Date(),\n      error: {\n        name: error.name,\n        message: error.message,\n        stack: error.stack,\n        context,\n      },\n    };\n\n    this.errors.set(key, report);\n\n    // Limit stored errors\n    if (this.errors.size > this.maxErrors) {\n      // Remove oldest error\n      const entries = [...this.errors.entries()];\n      const oldest = entries.toSorted(\n        (a: [string, ErrorReport], b: [string, ErrorReport]) =>\n          a[1].lastSeen.getTime() - b[1].lastSeen.getTime(),\n      )[0];\n      this.errors.delete(oldest[0]);\n    }\n\n    // Log immediately\n    console.error('[ERROR REPORTED]:', {\n      error: error.message,\n      count: 1,\n      context,\n    });\n\n    return key;\n  }\n\n  /**\n   * Get all error reports\n   */\n  getAllErrors(): ErrorReport[] {\n    return [...this.errors.values()];\n  }\n\n  /**\n   * Get a specific error by ID\n   */\n  getError(id: string): ErrorReport | undefined {\n    return this.errors.get(id);\n  }\n\n  /**\n   * Clear all errors\n   */\n  clear(): void {\n    this.errors.clear();\n  }\n\n  /**\n   * Clear a specific error\n   */\n  clearError(id: string): void {\n    this.errors.delete(id);\n  }\n}\n\n/**\n * Global error store instance\n */\nexport const errorStore = new ErrorStore();\n\n/**\n * Report an error to the error store\n *\n * @example\n * ```typescript\n * import { reportError } from 'autotel-tanstack/error-reporting';\n *\n * try {\n *   await riskyOperation();\n * } catch (error) {\n *   reportError(error as Error, {\n *     userId: context.userId,\n *     operation: 'riskyOperation',\n *   });\n *   throw error;\n * }\n * ```\n */\nexport function reportError(error: Error, context?: unknown): string {\n  return errorStore.reportError(error, context);\n}\n\n/**\n * Create an error reporting endpoint handler\n *\n * Returns a handler that exposes error reports in JSON format.\n * Use this to create an `/admin/errors` endpoint.\n *\n * @example\n * ```typescript\n * // routes/admin/errors.ts\n * import { createFileRoute } from '@tanstack/react-router';\n * import { json } from '@tanstack/react-start';\n * import { createErrorReportingHandler } from 'autotel-tanstack/error-reporting';\n *\n * export const Route = createFileRoute('/admin/errors')({\n *   server: {\n *     handlers: {\n *       GET: createErrorReportingHandler(),\n *     },\n *   },\n * });\n * ```\n */\nexport function createErrorReportingHandler() {\n  return async () => {\n    const { json } = await import('@tanstack/react-start');\n\n    return json({\n      errors: errorStore.getAllErrors(),\n    });\n  };\n}\n\n/**\n * Wrap a function with automatic error reporting\n *\n * Automatically reports errors to the error store.\n *\n * @example\n * ```typescript\n * import { withErrorReporting } from 'autotel-tanstack/error-reporting';\n *\n * const riskyOperation = createServerFn()\n *   .handler(withErrorReporting(async () => {\n *     return await performOperation();\n *   }, { operation: 'riskyOperation' }));\n * ```\n */\nexport function withErrorReporting<TArgs extends unknown[], TReturn>(\n  fn: (...args: TArgs) => Promise<TReturn>,\n  context?: Record<string, unknown>,\n): (...args: TArgs) => Promise<TReturn> {\n  return async (...args: TArgs): Promise<TReturn> => {\n    try {\n      return await fn(...args);\n    } catch (error) {\n      reportError(error as Error, context);\n      throw error;\n    }\n  };\n}\n"],"mappings":";;;;;;;AA4BA,IAAM,aAAN,MAAiB;CACf,AAAQ,yBAAS,IAAI,IAAyB;CAC9C,AAAiB,YAAY;;;;CAK7B,YAAY,OAAc,SAA2B;EACnD,MAAM,MAAM,GAAG,MAAM,KAAK,GAAG,MAAM;EACnC,MAAM,WAAW,KAAK,OAAO,IAAI,GAAG;EAEpC,IAAI,UAAU;GACZ,SAAS;GACT,SAAS,2BAAW,IAAI,KAAK;GAC7B,IAAI,SAEF,SAAS,MAAM,UAAU;IACvB,GAAI,SAAS,MAAM;IACnB,GAAI;GACN;GAEF,OAAO;EACT;EAGA,MAAM,SAAsB;GAC1B,IAAI;GACJ,OAAO;GACP,0BAAU,IAAI,KAAK;GACnB,OAAO;IACL,MAAM,MAAM;IACZ,SAAS,MAAM;IACf,OAAO,MAAM;IACb;GACF;EACF;EAEA,KAAK,OAAO,IAAI,KAAK,MAAM;EAG3B,IAAI,KAAK,OAAO,OAAO,KAAK,WAAW;GAGrC,MAAM,SAAS,CADE,GAAG,KAAK,OAAO,QAAQ,CACnB,CAAC,CAAC,UACpB,GAA0B,MACzB,EAAE,EAAE,CAAC,SAAS,QAAQ,IAAI,EAAE,EAAE,CAAC,SAAS,QAAQ,CACpD,CAAC,CAAC;GACF,KAAK,OAAO,OAAO,OAAO,EAAE;EAC9B;EAGA,QAAQ,MAAM,qBAAqB;GACjC,OAAO,MAAM;GACb,OAAO;GACP;EACF,CAAC;EAED,OAAO;CACT;;;;CAKA,eAA8B;EAC5B,OAAO,CAAC,GAAG,KAAK,OAAO,OAAO,CAAC;CACjC;;;;CAKA,SAAS,IAAqC;EAC5C,OAAO,KAAK,OAAO,IAAI,EAAE;CAC3B;;;;CAKA,QAAc;EACZ,KAAK,OAAO,MAAM;CACpB;;;;CAKA,WAAW,IAAkB;EAC3B,KAAK,OAAO,OAAO,EAAE;CACvB;AACF;;;;AAKA,MAAa,aAAa,IAAI,WAAW;;;;;;;;;;;;;;;;;;;AAoBzC,SAAgB,YAAY,OAAc,SAA2B;CACnE,OAAO,WAAW,YAAY,OAAO,OAAO;AAC9C;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,8BAA8B;CAC5C,OAAO,YAAY;EACjB,MAAM,EAAE,SAAS,MAAM,OAAO;EAE9B,OAAO,KAAK,EACV,QAAQ,WAAW,aAAa,EAClC,CAAC;CACH;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,mBACd,IACA,SACsC;CACtC,OAAO,OAAO,GAAG,SAAkC;EACjD,IAAI;GACF,OAAO,MAAM,GAAG,GAAG,IAAI;EACzB,SAAS,OAAO;GACd,YAAY,OAAgB,OAAO;GACnC,MAAM;EACR;CACF;AACF"}

package/dist/handlers.d.ts

@@ -1,11 +1,11 @@
-import { W as WrapStartHandlerConfig } from './types-m5OjZJ-4.js';
-import '@opentelemetry/api';
+import { s as WrapStartHandlerConfig } from "./types-pQgmQa4j.js";
 
+//#region src/handlers.d.ts
 /**
  * Request handler type (compatible with TanStack Start handlers)
  */
 type RequestHandler = (request: Request, opts?: {
-    context?: Record<string, unknown>;
+  context?: Record<string, unknown>;
 }) => Promise<Response> | Response;
 /**
  * Wrap a TanStack Start handler with OpenTelemetry tracing
@@ -66,5 +66,6 @@ declare function wrapStartHandler(config?: WrapStartHandlerConfig): (handler: Re
  * ```
  */
 declare function createTracedHandler(config?: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'>): (handler: RequestHandler) => RequestHandler;
-
+//#endregion
 export { createTracedHandler, wrapStartHandler };
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../src/handlers.ts"],"mappings":";;;;;AAQiB;KAKZ,cAAA,IACH,OAAA,EAAS,OAAA,EACT,IAAA;EAAS,OAAA,GAAU,MAAA;AAAA,MAChB,OAAA,CAAQ,QAAA,IAAY,QAAA;;;;;;;;;;;;;;;;AAAQ;AAgCjC;;;;;;;;;;;;;;iBAAgB,gBAAA,CACd,MAAA,GAAQ,sBAAA,IACN,OAAA,EAAS,cAAA,KAAmB,cAAA;AA6JhC;;;;;;;;;;;;;;;;AAE8C;;;;;;;;;;;AAF9C,iBAAgB,mBAAA,CACd,MAAA,GAAQ,IAAA,CAAK,sBAAA,yCACX,OAAA,EAAS,cAAA,KAAmB,cAAA"}

package/dist/handlers.js

@@ -1,7 +1,193 @@
-export { createTracedHandler, wrapStartHandler } from './chunk-FFQ4FJKE.js';
-import './chunk-CCME55EK.js';
-import './chunk-I4LX3LOG.js';
-import './chunk-NTY64BKS.js';
-import './chunk-EGRHWZRV.js';
-//# sourceMappingURL=handlers.js.map
+import { n as SPAN_ATTRIBUTES, t as DEFAULT_CONFIG } from "./types-BrccP0yX.js";
+import { extractContextFromRequest } from "./context.js";
+import { t as isExcludedPath } from "./route-filter-dLg-j3jR.js";
+import { SpanStatusCode, context } from "@opentelemetry/api";
+import { init, trace } from "autotel";
+
+//#region src/handlers.ts
+/**
+* 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));
+* ```
+*/
+function wrapStartHandler(config = {}) {
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	const service = config.service || process.env.OTEL_SERVICE_NAME || "tanstack-start";
+	const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	let headers = config.headers;
+	if (!headers && 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
+	});
+	return function wrapHandler(handler) {
+		return async function tracedHandler(request, opts) {
+			const url = new URL(request.url);
+			if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) return handler(request, opts);
+			const parentContext = extractContextFromRequest(request);
+			return context.with(parentContext, async () => {
+				const spanName = `${request.method} ${url.pathname}`;
+				return trace(spanName, async (ctx) => {
+					ctx.setAttributes({
+						[SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
+						[SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
+						[SPAN_ATTRIBUTES.URL_FULL]: request.url,
+						[SPAN_ATTRIBUTES.TANSTACK_TYPE]: "request"
+					});
+					if (url.search) ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);
+					if (mergedConfig.captureHeaders) for (const header of mergedConfig.captureHeaders) {
+						const value = request.headers.get(header);
+						if (value) ctx.setAttribute(`http.request.header.${header.toLowerCase()}`, value);
+					}
+					if (config.customAttributes) {
+						const customAttrs = config.customAttributes({
+							type: "request",
+							name: spanName,
+							request
+						});
+						ctx.setAttributes(customAttrs);
+					}
+					const startTime = Date.now();
+					try {
+						const response = await handler(request, opts);
+						const duration = Date.now() - startTime;
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						ctx.setAttribute(SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE, response.status);
+						if (response.status >= 400) ctx.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: `HTTP ${response.status}`
+						});
+						else ctx.setStatus({ code: SpanStatusCode.OK });
+						return response;
+					} catch (error) {
+						const duration = Date.now() - startTime;
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						if (mergedConfig.captureErrors) ctx.recordError(error);
+						throw error;
+					}
+				});
+			});
+		};
+	};
+}
+/**
+* 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));
+* ```
+*/
+function createTracedHandler(config = {}) {
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	return function wrapHandler(handler) {
+		return async function tracedHandler(request, opts) {
+			const url = new URL(request.url);
+			if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) return handler(request, opts);
+			const parentContext = extractContextFromRequest(request);
+			return context.with(parentContext, async () => {
+				const spanName = `${request.method} ${url.pathname}`;
+				return trace(spanName, async (ctx) => {
+					ctx.setAttributes({
+						[SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
+						[SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
+						[SPAN_ATTRIBUTES.TANSTACK_TYPE]: "request"
+					});
+					if (url.search) ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);
+					if (mergedConfig.captureHeaders) for (const header of mergedConfig.captureHeaders) {
+						const value = request.headers.get(header);
+						if (value) ctx.setAttribute(`http.request.header.${header.toLowerCase()}`, value);
+					}
+					if (config.customAttributes) {
+						const customAttrs = config.customAttributes({
+							type: "request",
+							name: spanName,
+							request
+						});
+						ctx.setAttributes(customAttrs);
+					}
+					const startTime = Date.now();
+					try {
+						const response = await handler(request, opts);
+						const duration = Date.now() - startTime;
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						ctx.setAttribute(SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE, response.status);
+						if (response.status >= 400) ctx.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: `HTTP ${response.status}`
+						});
+						else ctx.setStatus({ code: SpanStatusCode.OK });
+						return response;
+					} catch (error) {
+						const duration = Date.now() - startTime;
+						ctx.setAttribute(SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS, duration);
+						if (mergedConfig.captureErrors) ctx.recordError(error);
+						throw error;
+					}
+				});
+			});
+		};
+	};
+}
+
+//#endregion
+export { createTracedHandler, wrapStartHandler };
 //# sourceMappingURL=handlers.js.map

package/dist/handlers.js.map

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