autotel-adapters 2.0.22 → 2.0.23

package/dist/cloudflare.d.cts

@@ -2,7 +2,7 @@ import { n as FrameworkHandlerOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/cloudflare.d.ts
-interface CloudflareRequestLike {
+export interface CloudflareRequestLike {
   method?: string;
   url?: string;
   headers?: {
@@ -10,20 +10,20 @@ interface CloudflareRequestLike {
   } | Record<string, string | undefined>;
   cf?: Record<string, unknown>;
 }
-interface CloudflareExecutionContextLike {
+export interface CloudflareExecutionContextLike {
   waitUntil?: (promise: Promise<unknown>) => void;
   passThroughOnException?: () => void;
 }
-interface CloudflareHandlerContext<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike> {
+export interface CloudflareHandlerContext<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike> {
   request: TRequest;
   env: TEnv;
   executionContext: TContext;
 }
-interface CloudflareWithAutotelOptions<TEnv = unknown> extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface CloudflareWithAutotelOptions<TEnv = unknown> extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((request: CloudflareRequestLike, env: TEnv) => string);
   enrichRequest?: (request: CloudflareRequestLike, env: TEnv, ctx: CloudflareExecutionContextLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(request?: CloudflareRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
-declare function withAutotelFetch<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike, TReturn>(handler: (request: TRequest, env: TEnv, ctx: TContext) => TReturn | Promise<TReturn>, options?: CloudflareWithAutotelOptions<TEnv>): (request: TRequest, env: TEnv, ctx: TContext) => Promise<TReturn>;
+export declare function useLogger(request?: CloudflareRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function withAutotelFetch<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike, TReturn>(handler: (request: TRequest, env: TEnv, ctx: TContext) => TReturn | Promise<TReturn>, options?: CloudflareWithAutotelOptions<TEnv>): (request: TRequest, env: TEnv, ctx: TContext) => Promise<TReturn>;
 //#endregion
-export { CloudflareExecutionContextLike, CloudflareHandlerContext, CloudflareRequestLike, CloudflareWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelFetch };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/cloudflare.d.ts

@@ -2,7 +2,7 @@ import { n as FrameworkHandlerOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/cloudflare.d.ts
-interface CloudflareRequestLike {
+export interface CloudflareRequestLike {
   method?: string;
   url?: string;
   headers?: {
@@ -10,20 +10,20 @@ interface CloudflareRequestLike {
   } | Record<string, string | undefined>;
   cf?: Record<string, unknown>;
 }
-interface CloudflareExecutionContextLike {
+export interface CloudflareExecutionContextLike {
   waitUntil?: (promise: Promise<unknown>) => void;
   passThroughOnException?: () => void;
 }
-interface CloudflareHandlerContext<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike> {
+export interface CloudflareHandlerContext<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike> {
   request: TRequest;
   env: TEnv;
   executionContext: TContext;
 }
-interface CloudflareWithAutotelOptions<TEnv = unknown> extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface CloudflareWithAutotelOptions<TEnv = unknown> extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((request: CloudflareRequestLike, env: TEnv) => string);
   enrichRequest?: (request: CloudflareRequestLike, env: TEnv, ctx: CloudflareExecutionContextLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(request?: CloudflareRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
-declare function withAutotelFetch<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike, TReturn>(handler: (request: TRequest, env: TEnv, ctx: TContext) => TReturn | Promise<TReturn>, options?: CloudflareWithAutotelOptions<TEnv>): (request: TRequest, env: TEnv, ctx: TContext) => Promise<TReturn>;
+export declare function useLogger(request?: CloudflareRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function withAutotelFetch<TEnv, TRequest extends CloudflareRequestLike, TContext extends CloudflareExecutionContextLike, TReturn>(handler: (request: TRequest, env: TEnv, ctx: TContext) => TReturn | Promise<TReturn>, options?: CloudflareWithAutotelOptions<TEnv>): (request: TRequest, env: TEnv, ctx: TContext) => Promise<TReturn>;
 //#endregion
-export { CloudflareExecutionContextLike, CloudflareHandlerContext, CloudflareRequestLike, CloudflareWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelFetch };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/core.d.cts

@@ -2,13 +2,13 @@ import { _ as RouteAdapterOptions, f as toRouteAdapterOptions, n as FrameworkHan
 import { DrainPipelineOptions, ParsedError, PipelineDrainFn, RequestLogSnapshot, RequestLogger, RequestLoggerOptions, StructuredError, StructuredErrorInput } from "autotel";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/core.d.ts
-type BaseAdapterOptions = RouteAdapterOptions;
-interface AdapterUseLoggerOptions<TContext> {
+export type BaseAdapterOptions = RouteAdapterOptions;
+export interface AdapterUseLoggerOptions<TContext> {
   adapterName: string;
   enrich?: (context: TContext) => Record<string, unknown> | undefined;
 }
-declare function createUseLogger<TContext = unknown>(options: AdapterUseLoggerOptions<TContext>): (context?: TContext, requestLoggerOptions?: RequestLoggerOptions) => RequestLogger;
-interface RequestRunnerOptions extends RouteAdapterOptions {
+export declare function createUseLogger<TContext = unknown>(options: AdapterUseLoggerOptions<TContext>): (context?: TContext, requestLoggerOptions?: RequestLoggerOptions) => RequestLogger;
+export interface RequestRunnerOptions extends RouteAdapterOptions {
   requestLoggerOptions?: RequestLoggerOptions;
   /** HTTP route used for include/exclude filtering. */
   path?: string;
@@ -23,12 +23,12 @@ interface RequestRunnerOptions extends RouteAdapterOptions {
  * storage so `useLogger()` resolves it, records thrown errors, and emits one
  * wide event when the handler settles (unless `autoEmit` is `false`).
  */
-declare function createRequestRunner(storage: AsyncLocalStorage<RequestLogger>): <T>(spanName: string, enrich: (log: RequestLogger) => void, handler: () => T | Promise<T>, options?: RequestRunnerOptions) => Promise<T>;
+export declare function createRequestRunner(storage: AsyncLocalStorage<RequestLogger>): <T>(spanName: string, enrich: (log: RequestLogger) => void, handler: () => T | Promise<T>, options?: RequestRunnerOptions) => Promise<T>;
 /**
  * Description of a single adapter config field. `env` is the ordered list of
  * environment variables to fall back to.
  */
-interface ConfigField<T> {
+export interface ConfigField<T> {
   key: keyof T & string;
   env?: string[];
 }
@@ -49,7 +49,7 @@ interface ConfigField<T> {
  * }
  * ```
  */
-declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Partial<T>): boolean;
+export declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Partial<T>): boolean;
 /**
  * Resolve adapter configuration with the standard priority chain:
  *
@@ -63,10 +63,10 @@ declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Par
  * field is not set by overrides). Adapters that have no probe target may pass
  * `() => Promise.resolve(undefined)`.
  */
-declare function resolveAdapterConfig<T>(namespace: string, fields: ConfigField<T>[], overrides: Partial<T> | undefined, probe: () => Promise<Record<string, any> | undefined>): Promise<Partial<T>>;
-type HeadersLike = {
+export declare function resolveAdapterConfig<T>(namespace: string, fields: ConfigField<T>[], overrides: Partial<T> | undefined, probe: () => Promise<Record<string, any> | undefined>): Promise<Partial<T>>;
+export type HeadersLike = {
   get(name: string): string | null;
 } | Record<string, string | undefined>;
-declare function getHeader(headers: HeadersLike | undefined, name: string): string | undefined;
+export declare function getHeader(headers: HeadersLike | undefined, name: string): string | undefined;
 //#endregion
-export { AdapterUseLoggerOptions, BaseAdapterOptions, ConfigField, type DrainPipelineOptions, type FrameworkHandlerOptions, HeadersLike, type IntegratedCompletionOptions, type ParsedError, type PipelineDrainFn, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, RequestRunnerOptions, type RouteAdapterOptions, type StructuredError, type StructuredErrorInput, createRequestRunner, createUseLogger, getHeader, resolveAdapterConfig, shouldProbeRuntime, toRouteAdapterOptions };
+export { type DrainPipelineOptions, type FrameworkHandlerOptions, type IntegratedCompletionOptions, type ParsedError, type PipelineDrainFn, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, type RouteAdapterOptions, type StructuredError, type StructuredErrorInput, toRouteAdapterOptions };

package/dist/core.d.ts

@@ -2,13 +2,13 @@ import { _ as RouteAdapterOptions, f as toRouteAdapterOptions, n as FrameworkHan
 import { DrainPipelineOptions, ParsedError, PipelineDrainFn, RequestLogSnapshot, RequestLogger, RequestLoggerOptions, StructuredError, StructuredErrorInput } from "autotel";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/core.d.ts
-type BaseAdapterOptions = RouteAdapterOptions;
-interface AdapterUseLoggerOptions<TContext> {
+export type BaseAdapterOptions = RouteAdapterOptions;
+export interface AdapterUseLoggerOptions<TContext> {
   adapterName: string;
   enrich?: (context: TContext) => Record<string, unknown> | undefined;
 }
-declare function createUseLogger<TContext = unknown>(options: AdapterUseLoggerOptions<TContext>): (context?: TContext, requestLoggerOptions?: RequestLoggerOptions) => RequestLogger;
-interface RequestRunnerOptions extends RouteAdapterOptions {
+export declare function createUseLogger<TContext = unknown>(options: AdapterUseLoggerOptions<TContext>): (context?: TContext, requestLoggerOptions?: RequestLoggerOptions) => RequestLogger;
+export interface RequestRunnerOptions extends RouteAdapterOptions {
   requestLoggerOptions?: RequestLoggerOptions;
   /** HTTP route used for include/exclude filtering. */
   path?: string;
@@ -23,12 +23,12 @@ interface RequestRunnerOptions extends RouteAdapterOptions {
  * storage so `useLogger()` resolves it, records thrown errors, and emits one
  * wide event when the handler settles (unless `autoEmit` is `false`).
  */
-declare function createRequestRunner(storage: AsyncLocalStorage<RequestLogger>): <T>(spanName: string, enrich: (log: RequestLogger) => void, handler: () => T | Promise<T>, options?: RequestRunnerOptions) => Promise<T>;
+export declare function createRequestRunner(storage: AsyncLocalStorage<RequestLogger>): <T>(spanName: string, enrich: (log: RequestLogger) => void, handler: () => T | Promise<T>, options?: RequestRunnerOptions) => Promise<T>;
 /**
  * Description of a single adapter config field. `env` is the ordered list of
  * environment variables to fall back to.
  */
-interface ConfigField<T> {
+export interface ConfigField<T> {
   key: keyof T & string;
   env?: string[];
 }
@@ -49,7 +49,7 @@ interface ConfigField<T> {
  * }
  * ```
  */
-declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Partial<T>): boolean;
+export declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Partial<T>): boolean;
 /**
  * Resolve adapter configuration with the standard priority chain:
  *
@@ -63,10 +63,10 @@ declare function shouldProbeRuntime<T>(fields: ConfigField<T>[], overrides?: Par
  * field is not set by overrides). Adapters that have no probe target may pass
  * `() => Promise.resolve(undefined)`.
  */
-declare function resolveAdapterConfig<T>(namespace: string, fields: ConfigField<T>[], overrides: Partial<T> | undefined, probe: () => Promise<Record<string, any> | undefined>): Promise<Partial<T>>;
-type HeadersLike = {
+export declare function resolveAdapterConfig<T>(namespace: string, fields: ConfigField<T>[], overrides: Partial<T> | undefined, probe: () => Promise<Record<string, any> | undefined>): Promise<Partial<T>>;
+export type HeadersLike = {
   get(name: string): string | null;
 } | Record<string, string | undefined>;
-declare function getHeader(headers: HeadersLike | undefined, name: string): string | undefined;
+export declare function getHeader(headers: HeadersLike | undefined, name: string): string | undefined;
 //#endregion
-export { AdapterUseLoggerOptions, BaseAdapterOptions, ConfigField, type DrainPipelineOptions, type FrameworkHandlerOptions, HeadersLike, type IntegratedCompletionOptions, type ParsedError, type PipelineDrainFn, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, RequestRunnerOptions, type RouteAdapterOptions, type StructuredError, type StructuredErrorInput, createRequestRunner, createUseLogger, getHeader, resolveAdapterConfig, shouldProbeRuntime, toRouteAdapterOptions };
+export { type DrainPipelineOptions, type FrameworkHandlerOptions, type IntegratedCompletionOptions, type ParsedError, type PipelineDrainFn, type RequestLogSnapshot, type RequestLogger, type RequestLoggerOptions, type RouteAdapterOptions, type StructuredError, type StructuredErrorInput, toRouteAdapterOptions };

package/dist/elysia.d.cts

@@ -2,16 +2,16 @@ import { n as FrameworkHandlerOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/elysia.d.ts
-interface ElysiaContextLike {
+export interface ElysiaContextLike {
   request: Request;
   path: string;
 }
-interface ElysiaWithAutotelOptions extends FrameworkHandlerOptions {
+export interface ElysiaWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (ctx: ElysiaContextLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare function withAutotelHandler<T>(handler: (ctx: ElysiaContextLike) => T | Promise<T>, options?: ElysiaWithAutotelOptions): (ctx: ElysiaContextLike) => Promise<T>;
+export declare function useLogger(): RequestLogger;
+export declare function withAutotelHandler<T>(handler: (ctx: ElysiaContextLike) => T | Promise<T>, options?: ElysiaWithAutotelOptions): (ctx: ElysiaContextLike) => Promise<T>;
 /** @deprecated Use {@link withAutotelHandler}. */
-declare const autotel: typeof withAutotelHandler;
+export declare const autotel: typeof withAutotelHandler;
 //#endregion
-export { ElysiaContextLike, ElysiaWithAutotelOptions, autotel, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelHandler };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/elysia.d.ts

@@ -2,16 +2,16 @@ import { n as FrameworkHandlerOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/elysia.d.ts
-interface ElysiaContextLike {
+export interface ElysiaContextLike {
   request: Request;
   path: string;
 }
-interface ElysiaWithAutotelOptions extends FrameworkHandlerOptions {
+export interface ElysiaWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (ctx: ElysiaContextLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare function withAutotelHandler<T>(handler: (ctx: ElysiaContextLike) => T | Promise<T>, options?: ElysiaWithAutotelOptions): (ctx: ElysiaContextLike) => Promise<T>;
+export declare function useLogger(): RequestLogger;
+export declare function withAutotelHandler<T>(handler: (ctx: ElysiaContextLike) => T | Promise<T>, options?: ElysiaWithAutotelOptions): (ctx: ElysiaContextLike) => Promise<T>;
 /** @deprecated Use {@link withAutotelHandler}. */
-declare const autotel: typeof withAutotelHandler;
+export declare const autotel: typeof withAutotelHandler;
 //#endregion
-export { ElysiaContextLike, ElysiaWithAutotelOptions, autotel, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelHandler };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/express.d.cts

@@ -2,7 +2,7 @@ import { _ as RouteAdapterOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/express.d.ts
-interface ExpressRequestLike {
+export interface ExpressRequestLike {
   method?: string;
   originalUrl?: string;
   url?: string;
@@ -12,22 +12,22 @@ interface ExpressRequestLike {
   };
   headers?: Record<string, string | string[] | undefined>;
 }
-interface ExpressResponseLike {
+export interface ExpressResponseLike {
   statusCode?: number;
 }
-type ExpressNext = (err?: unknown) => void;
-interface ExpressWithAutotelOptions extends RouteAdapterOptions {
+export type ExpressNext = (err?: unknown) => void;
+export interface ExpressWithAutotelOptions extends RouteAdapterOptions {
   spanName?: string | ((request: ExpressRequestLike) => string);
   requestLoggerOptions?: RequestLoggerOptions;
   enrichRequest?: (request: ExpressRequestLike) => Record<string, unknown> | undefined;
   autoEmit?: boolean;
 }
-declare function useLogger(request?: ExpressRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function useLogger(request?: ExpressRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
 /**
  * Wrap an Express route handler. Each request opens a span, gets a
  * request-scoped logger (via `useLogger(req)`), and emits one wide event when
  * the handler settles. Thrown errors are recorded and forwarded to `next`.
  */
-declare function withAutotel<TReq extends ExpressRequestLike, TRes extends ExpressResponseLike, TReturn>(handler: (req: TReq, res: TRes, next?: ExpressNext) => TReturn | Promise<TReturn>, options?: ExpressWithAutotelOptions): (req: TReq, res: TRes, next?: ExpressNext) => Promise<TReturn | undefined>;
+export declare function withAutotel<TReq extends ExpressRequestLike, TRes extends ExpressResponseLike, TReturn>(handler: (req: TReq, res: TRes, next?: ExpressNext) => TReturn | Promise<TReturn>, options?: ExpressWithAutotelOptions): (req: TReq, res: TRes, next?: ExpressNext) => Promise<TReturn | undefined>;
 //#endregion
-export { ExpressNext, ExpressRequestLike, ExpressResponseLike, ExpressWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/express.d.ts

@@ -2,7 +2,7 @@ import { _ as RouteAdapterOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/express.d.ts
-interface ExpressRequestLike {
+export interface ExpressRequestLike {
   method?: string;
   originalUrl?: string;
   url?: string;
@@ -12,22 +12,22 @@ interface ExpressRequestLike {
   };
   headers?: Record<string, string | string[] | undefined>;
 }
-interface ExpressResponseLike {
+export interface ExpressResponseLike {
   statusCode?: number;
 }
-type ExpressNext = (err?: unknown) => void;
-interface ExpressWithAutotelOptions extends RouteAdapterOptions {
+export type ExpressNext = (err?: unknown) => void;
+export interface ExpressWithAutotelOptions extends RouteAdapterOptions {
   spanName?: string | ((request: ExpressRequestLike) => string);
   requestLoggerOptions?: RequestLoggerOptions;
   enrichRequest?: (request: ExpressRequestLike) => Record<string, unknown> | undefined;
   autoEmit?: boolean;
 }
-declare function useLogger(request?: ExpressRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function useLogger(request?: ExpressRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
 /**
  * Wrap an Express route handler. Each request opens a span, gets a
  * request-scoped logger (via `useLogger(req)`), and emits one wide event when
  * the handler settles. Thrown errors are recorded and forwarded to `next`.
  */
-declare function withAutotel<TReq extends ExpressRequestLike, TRes extends ExpressResponseLike, TReturn>(handler: (req: TReq, res: TRes, next?: ExpressNext) => TReturn | Promise<TReturn>, options?: ExpressWithAutotelOptions): (req: TReq, res: TRes, next?: ExpressNext) => Promise<TReturn | undefined>;
+export declare function withAutotel<TReq extends ExpressRequestLike, TRes extends ExpressResponseLike, TReturn>(handler: (req: TReq, res: TRes, next?: ExpressNext) => TReturn | Promise<TReturn>, options?: ExpressWithAutotelOptions): (req: TReq, res: TRes, next?: ExpressNext) => Promise<TReturn | undefined>;
 //#endregion
-export { ExpressNext, ExpressRequestLike, ExpressResponseLike, ExpressWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/fastify.d.cts

@@ -2,7 +2,7 @@ import { _ as RouteAdapterOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/fastify.d.ts
-interface FastifyRequestLike {
+export interface FastifyRequestLike {
   method?: string;
   url?: string;
   routeOptions?: {
@@ -12,22 +12,22 @@ interface FastifyRequestLike {
   id?: string;
   headers?: Record<string, string | string[] | undefined>;
 }
-interface FastifyReplyLike {
+export interface FastifyReplyLike {
   statusCode?: number;
 }
-interface FastifyWithAutotelOptions extends RouteAdapterOptions {
+export interface FastifyWithAutotelOptions extends RouteAdapterOptions {
   spanName?: string | ((request: FastifyRequestLike) => string);
   requestLoggerOptions?: RequestLoggerOptions;
   enrichRequest?: (request: FastifyRequestLike) => Record<string, unknown> | undefined;
   autoEmit?: boolean;
 }
-declare function useLogger(request?: FastifyRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function useLogger(request?: FastifyRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
 /**
  * Wrap a Fastify route handler. Each request opens a span, gets a
  * request-scoped logger (via `useLogger(request)`), and emits one wide event
  * when the handler settles. Thrown errors are recorded, then rethrown for
  * Fastify's error handling.
  */
-declare function withAutotel<TReq extends FastifyRequestLike, TRes extends FastifyReplyLike, TReturn>(handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>, options?: FastifyWithAutotelOptions): (request: TReq, reply: TRes) => Promise<TReturn>;
+export declare function withAutotel<TReq extends FastifyRequestLike, TRes extends FastifyReplyLike, TReturn>(handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>, options?: FastifyWithAutotelOptions): (request: TReq, reply: TRes) => Promise<TReturn>;
 //#endregion
-export { FastifyReplyLike, FastifyRequestLike, FastifyWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/fastify.d.ts

@@ -2,7 +2,7 @@ import { _ as RouteAdapterOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/fastify.d.ts
-interface FastifyRequestLike {
+export interface FastifyRequestLike {
   method?: string;
   url?: string;
   routeOptions?: {
@@ -12,22 +12,22 @@ interface FastifyRequestLike {
   id?: string;
   headers?: Record<string, string | string[] | undefined>;
 }
-interface FastifyReplyLike {
+export interface FastifyReplyLike {
   statusCode?: number;
 }
-interface FastifyWithAutotelOptions extends RouteAdapterOptions {
+export interface FastifyWithAutotelOptions extends RouteAdapterOptions {
   spanName?: string | ((request: FastifyRequestLike) => string);
   requestLoggerOptions?: RequestLoggerOptions;
   enrichRequest?: (request: FastifyRequestLike) => Record<string, unknown> | undefined;
   autoEmit?: boolean;
 }
-declare function useLogger(request?: FastifyRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function useLogger(request?: FastifyRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
 /**
  * Wrap a Fastify route handler. Each request opens a span, gets a
  * request-scoped logger (via `useLogger(request)`), and emits one wide event
  * when the handler settles. Thrown errors are recorded, then rethrown for
  * Fastify's error handling.
  */
-declare function withAutotel<TReq extends FastifyRequestLike, TRes extends FastifyReplyLike, TReturn>(handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>, options?: FastifyWithAutotelOptions): (request: TReq, reply: TRes) => Promise<TReturn>;
+export declare function withAutotel<TReq extends FastifyRequestLike, TRes extends FastifyReplyLike, TReturn>(handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>, options?: FastifyWithAutotelOptions): (request: TReq, reply: TRes) => Promise<TReturn>;
 //#endregion
-export { FastifyReplyLike, FastifyRequestLike, FastifyWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/hono.d.cts

@@ -3,13 +3,13 @@ import "./core.cjs";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 import { Context } from "hono";
 //#region src/hono.d.ts
-interface HonoWithAutotelOptions extends FrameworkHandlerOptions {
+export interface HonoWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (c: Context) => Record<string, unknown> | undefined;
 }
 /** Request logger inside autotelMiddleware / traced handlers. */
-declare function useLogger(c?: Context): RequestLogger;
-declare function autotelMiddleware(options?: HonoWithAutotelOptions): (c: Context, next: () => Promise<void>) => Promise<void>;
+export declare function useLogger(c?: Context): RequestLogger;
+export declare function autotelMiddleware(options?: HonoWithAutotelOptions): (c: Context, next: () => Promise<void>) => Promise<void>;
 /** Alias for {@link useLogger} inside autotelMiddleware. */
-declare const useLoggerFromContext: typeof useLogger;
+export declare const useLoggerFromContext: typeof useLogger;
 //#endregion
-export { HonoWithAutotelOptions, autotelMiddleware, createDrainPipeline, createStructuredError, parseError, useLogger, useLoggerFromContext };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/hono.d.ts

@@ -3,13 +3,13 @@ import "./core.js";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 import { Context } from "hono";
 //#region src/hono.d.ts
-interface HonoWithAutotelOptions extends FrameworkHandlerOptions {
+export interface HonoWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (c: Context) => Record<string, unknown> | undefined;
 }
 /** Request logger inside autotelMiddleware / traced handlers. */
-declare function useLogger(c?: Context): RequestLogger;
-declare function autotelMiddleware(options?: HonoWithAutotelOptions): (c: Context, next: () => Promise<void>) => Promise<void>;
+export declare function useLogger(c?: Context): RequestLogger;
+export declare function autotelMiddleware(options?: HonoWithAutotelOptions): (c: Context, next: () => Promise<void>) => Promise<void>;
 /** Alias for {@link useLogger} inside autotelMiddleware. */
-declare const useLoggerFromContext: typeof useLogger;
+export declare const useLoggerFromContext: typeof useLogger;
 //#endregion
-export { HonoWithAutotelOptions, autotelMiddleware, createDrainPipeline, createStructuredError, parseError, useLogger, useLoggerFromContext };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/nestjs.d.cts

@@ -3,7 +3,7 @@ import "./core.cjs";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 import { Observable } from "rxjs";
 //#region src/nestjs.d.ts
-interface NestExecutionContextLike {
+export interface NestExecutionContextLike {
   getClass: () => {
     name: string;
   };
@@ -16,21 +16,21 @@ interface NestExecutionContextLike {
     getResponse: () => NestResponseLike;
   };
 }
-interface NestRequestLike {
+export interface NestRequestLike {
   method?: string;
   url?: string;
   originalUrl?: string;
   path?: string;
   headers?: Record<string, string | string[] | undefined>;
 }
-interface NestResponseLike {
+export interface NestResponseLike {
   statusCode?: number;
 }
-interface NestWithAutotelOptions extends FrameworkHandlerOptions {
+export interface NestWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (request: NestRequestLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare class AutotelInterceptor {
+export declare function useLogger(): RequestLogger;
+export declare class AutotelInterceptor {
   readonly options: NestWithAutotelOptions;
   constructor(options?: NestWithAutotelOptions);
   intercept(executionCtx: NestExecutionContextLike, next: {
@@ -38,4 +38,4 @@ declare class AutotelInterceptor {
   }): Observable<unknown>;
 }
 //#endregion
-export { AutotelInterceptor, NestExecutionContextLike, NestRequestLike, NestResponseLike, NestWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/nestjs.d.ts

@@ -3,7 +3,7 @@ import "./core.js";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 import { Observable } from "rxjs";
 //#region src/nestjs.d.ts
-interface NestExecutionContextLike {
+export interface NestExecutionContextLike {
   getClass: () => {
     name: string;
   };
@@ -16,21 +16,21 @@ interface NestExecutionContextLike {
     getResponse: () => NestResponseLike;
   };
 }
-interface NestRequestLike {
+export interface NestRequestLike {
   method?: string;
   url?: string;
   originalUrl?: string;
   path?: string;
   headers?: Record<string, string | string[] | undefined>;
 }
-interface NestResponseLike {
+export interface NestResponseLike {
   statusCode?: number;
 }
-interface NestWithAutotelOptions extends FrameworkHandlerOptions {
+export interface NestWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (request: NestRequestLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare class AutotelInterceptor {
+export declare function useLogger(): RequestLogger;
+export declare class AutotelInterceptor {
   readonly options: NestWithAutotelOptions;
   constructor(options?: NestWithAutotelOptions);
   intercept(executionCtx: NestExecutionContextLike, next: {
@@ -38,4 +38,4 @@ declare class AutotelInterceptor {
   }): Observable<unknown>;
 }
 //#endregion
-export { AutotelInterceptor, NestExecutionContextLike, NestRequestLike, NestResponseLike, NestWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/next.d.cts

@@ -2,18 +2,18 @@ import { n as FrameworkHandlerOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/next.d.ts
-interface NextRequestLike {
+export interface NextRequestLike {
   method?: string;
   url?: string;
   headers?: {
     get(name: string): string | null;
   } | Record<string, string | undefined>;
 }
-interface NextWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface NextWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((request?: NextRequestLike) => string);
   enrichRequest?: (request?: NextRequestLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(request?: NextRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
-declare function withAutotel<TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => TReturn | Promise<TReturn>, options?: NextWithAutotelOptions): (...args: TArgs) => Promise<TReturn>;
+export declare function useLogger(request?: NextRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function withAutotel<TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => TReturn | Promise<TReturn>, options?: NextWithAutotelOptions): (...args: TArgs) => Promise<TReturn>;
 //#endregion
-export { NextRequestLike, NextWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/next.d.ts

@@ -2,18 +2,18 @@ import { n as FrameworkHandlerOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/next.d.ts
-interface NextRequestLike {
+export interface NextRequestLike {
   method?: string;
   url?: string;
   headers?: {
     get(name: string): string | null;
   } | Record<string, string | undefined>;
 }
-interface NextWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface NextWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((request?: NextRequestLike) => string);
   enrichRequest?: (request?: NextRequestLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(request?: NextRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
-declare function withAutotel<TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => TReturn | Promise<TReturn>, options?: NextWithAutotelOptions): (...args: TArgs) => Promise<TReturn>;
+export declare function useLogger(request?: NextRequestLike, requestLoggerOptions?: RequestLoggerOptions): RequestLogger;
+export declare function withAutotel<TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => TReturn | Promise<TReturn>, options?: NextWithAutotelOptions): (...args: TArgs) => Promise<TReturn>;
 //#endregion
-export { NextRequestLike, NextWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotel };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/nitro.d.cts

@@ -2,16 +2,16 @@ import { n as FrameworkHandlerOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/nitro.d.ts
-interface NitroEventLike {
+export interface NitroEventLike {
   method?: string;
   path?: string;
   context?: Record<string, unknown>;
 }
-interface NitroWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface NitroWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((event: NitroEventLike) => string);
   enrichRequest?: (event: NitroEventLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(event?: NitroEventLike, serviceOrOptions?: string | RequestLoggerOptions): RequestLogger;
-declare function withAutotelEventHandler<TEvent extends NitroEventLike, TReturn>(handler: (event: TEvent) => TReturn | Promise<TReturn>, options?: NitroWithAutotelOptions): (event: TEvent) => Promise<TReturn>;
+export declare function useLogger(event?: NitroEventLike, serviceOrOptions?: string | RequestLoggerOptions): RequestLogger;
+export declare function withAutotelEventHandler<TEvent extends NitroEventLike, TReturn>(handler: (event: TEvent) => TReturn | Promise<TReturn>, options?: NitroWithAutotelOptions): (event: TEvent) => Promise<TReturn>;
 //#endregion
-export { NitroEventLike, NitroWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelEventHandler };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/nitro.d.ts

@@ -2,16 +2,16 @@ import { n as FrameworkHandlerOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, RequestLoggerOptions, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/nitro.d.ts
-interface NitroEventLike {
+export interface NitroEventLike {
   method?: string;
   path?: string;
   context?: Record<string, unknown>;
 }
-interface NitroWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
+export interface NitroWithAutotelOptions extends Omit<FrameworkHandlerOptions, 'spanName'> {
   spanName?: string | ((event: NitroEventLike) => string);
   enrichRequest?: (event: NitroEventLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(event?: NitroEventLike, serviceOrOptions?: string | RequestLoggerOptions): RequestLogger;
-declare function withAutotelEventHandler<TEvent extends NitroEventLike, TReturn>(handler: (event: TEvent) => TReturn | Promise<TReturn>, options?: NitroWithAutotelOptions): (event: TEvent) => Promise<TReturn>;
+export declare function useLogger(event?: NitroEventLike, serviceOrOptions?: string | RequestLoggerOptions): RequestLogger;
+export declare function withAutotelEventHandler<TEvent extends NitroEventLike, TReturn>(handler: (event: TEvent) => TReturn | Promise<TReturn>, options?: NitroWithAutotelOptions): (event: TEvent) => Promise<TReturn>;
 //#endregion
-export { NitroEventLike, NitroWithAutotelOptions, createDrainPipeline, createStructuredError, parseError, useLogger, withAutotelEventHandler };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/sveltekit.d.cts

@@ -2,7 +2,7 @@ import { n as FrameworkHandlerOptions } from "./integration-D9g_qI5y.cjs";
 import "./core.cjs";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/sveltekit.d.ts
-interface SvelteKitEventLike {
+export interface SvelteKitEventLike {
   request: Request;
   url: URL;
   route?: {
@@ -10,14 +10,14 @@ interface SvelteKitEventLike {
   };
   locals?: Record<string, unknown>;
 }
-interface SvelteKitHandleInput {
+export interface SvelteKitHandleInput {
   event: SvelteKitEventLike;
   resolve: (event: SvelteKitEventLike) => Response | Promise<Response>;
 }
-interface SvelteKitWithAutotelOptions extends FrameworkHandlerOptions {
+export interface SvelteKitWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (event: SvelteKitEventLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare function autotelHandle(options?: SvelteKitWithAutotelOptions): ({ event, resolve }: SvelteKitHandleInput) => Promise<Response>;
+export declare function useLogger(): RequestLogger;
+export declare function autotelHandle(options?: SvelteKitWithAutotelOptions): ({ event, resolve }: SvelteKitHandleInput) => Promise<Response>;
 //#endregion
-export { SvelteKitEventLike, SvelteKitHandleInput, SvelteKitWithAutotelOptions, autotelHandle, createDrainPipeline, createStructuredError, parseError, useLogger };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/sveltekit.d.ts

@@ -2,7 +2,7 @@ import { n as FrameworkHandlerOptions } from "./integration-CQMpu5E4.js";
 import "./core.js";
 import { RequestLogger, createDrainPipeline, createStructuredError, parseError } from "autotel";
 //#region src/sveltekit.d.ts
-interface SvelteKitEventLike {
+export interface SvelteKitEventLike {
   request: Request;
   url: URL;
   route?: {
@@ -10,14 +10,14 @@ interface SvelteKitEventLike {
   };
   locals?: Record<string, unknown>;
 }
-interface SvelteKitHandleInput {
+export interface SvelteKitHandleInput {
   event: SvelteKitEventLike;
   resolve: (event: SvelteKitEventLike) => Response | Promise<Response>;
 }
-interface SvelteKitWithAutotelOptions extends FrameworkHandlerOptions {
+export interface SvelteKitWithAutotelOptions extends FrameworkHandlerOptions {
   enrichRequest?: (event: SvelteKitEventLike) => Record<string, unknown> | undefined;
 }
-declare function useLogger(): RequestLogger;
-declare function autotelHandle(options?: SvelteKitWithAutotelOptions): ({ event, resolve }: SvelteKitHandleInput) => Promise<Response>;
+export declare function useLogger(): RequestLogger;
+export declare function autotelHandle(options?: SvelteKitWithAutotelOptions): ({ event, resolve }: SvelteKitHandleInput) => Promise<Response>;
 //#endregion
-export { SvelteKitEventLike, SvelteKitHandleInput, SvelteKitWithAutotelOptions, autotelHandle, createDrainPipeline, createStructuredError, parseError, useLogger };
+export { createDrainPipeline, createStructuredError, parseError };

package/dist/tanstack.d.cts

@@ -1,7 +1,6 @@
 //#region src/tanstack.d.ts
-declare const useLogger: (context?: {
+export declare const useLogger: (context?: {
   pathname?: string;
   method?: string;
 } | undefined, requestLoggerOptions?: import("autotel").RequestLoggerOptions) => import("autotel").RequestLogger;
-//#endregion
-export { useLogger };
+//#endregion

package/dist/tanstack.d.ts

@@ -1,7 +1,6 @@
 //#region src/tanstack.d.ts
-declare const useLogger: (context?: {
+export declare const useLogger: (context?: {
   pathname?: string;
   method?: string;
 } | undefined, requestLoggerOptions?: import("autotel").RequestLoggerOptions) => import("autotel").RequestLogger;
-//#endregion
-export { useLogger };
+//#endregion

package/dist/toolkit/index.d.cts

@@ -11,31 +11,31 @@ import { ForkLifecycle as ForkLifecycle$1, RequestLogger } from "autotel";
  * omitted there is no keep-alive guarantee: on a freezing runtime the drain may
  * not finish, so callers that need delivery must supply `waitUntil`.
  */
-declare function extendDeferredDrain(drainPromise: Promise<unknown>, waitUntil?: (promise: Promise<unknown>) => void): void;
+export declare function extendDeferredDrain(drainPromise: Promise<unknown>, waitUntil?: (promise: Promise<unknown>) => void): void;
 //#endregion
 //#region src/toolkit/fork.d.ts
 /**
  * Wrap an existing request logger's `fork()` so adapter lifecycle hooks run
  * for background work spawned after the response returns.
  */
-declare function attachForkToLogger(logger: RequestLogger, lifecycle: ForkLifecycle$1): void;
+export declare function attachForkToLogger(logger: RequestLogger, lifecycle: ForkLifecycle$1): void;
 //#endregion
 //#region src/toolkit/stream-response.d.ts
 interface StreamCompleteMeta {
   status: number;
   error?: Error;
 }
-declare function isStreamingResponse(response: Response): boolean;
+export declare function isStreamingResponse(response: Response): boolean;
 /**
  * Whether framework integrations should defer wide-event emit until the response
  * body finishes. Static string/JSON bodies are excluded even though they use a
  * ReadableStream under the hood in the Fetch API.
  */
-declare function shouldDeferEmitForResponse(response: Response): boolean;
+export declare function shouldDeferEmitForResponse(response: Response): boolean;
 /**
  * Observe a streaming Response body and invoke `onComplete` once when the body
  * closes, errors, or is cancelled.
  */
-declare function bindStreamingResponseLifecycle(response: Response, onComplete: (meta: StreamCompleteMeta) => void | Promise<void>): Response;
+export declare function bindStreamingResponseLifecycle(response: Response, onComplete: (meta: StreamCompleteMeta) => void | Promise<void>): Response;
 //#endregion
-export { type BaseAdapterOptions, type ExtractedRequest, type ForkLifecycle, type FrameworkHandlerOptions, type FrameworkIntegrationHelpers, type FrameworkIntegrationSpec, type FrameworkRequestHandle, type IntegratedCompletionOptions, type MiddlewareLoggerOptions, type MiddlewareLoggerResult, type RouteAdapterOptions, type RouteFilterOptions, type RouteServiceConfig, type StreamCompleteMeta, type TailSamplingContext, applyLoggerEnrichment, attachForkToLogger, bindStreamingResponseLifecycle, buildTracedOptions, completeIntegratedRequest, createLoggerStorage, createMiddlewareLogger, createStorageForkLifecycle, defineFrameworkIntegration, extendDeferredDrain, getServiceForPath, isStreamingResponse, matchesRoutePattern, mergeRequestLoggerOptions, runWithIntegratedHandle, shouldDeferEmitForResponse, shouldInstrumentPath, toRouteAdapterOptions };
+export { type BaseAdapterOptions, type ExtractedRequest, type ForkLifecycle, type FrameworkHandlerOptions, type FrameworkIntegrationHelpers, type FrameworkIntegrationSpec, type FrameworkRequestHandle, type IntegratedCompletionOptions, type MiddlewareLoggerOptions, type MiddlewareLoggerResult, type RouteAdapterOptions, type RouteFilterOptions, type RouteServiceConfig, type StreamCompleteMeta, type TailSamplingContext, applyLoggerEnrichment, buildTracedOptions, completeIntegratedRequest, createLoggerStorage, createMiddlewareLogger, createStorageForkLifecycle, defineFrameworkIntegration, getServiceForPath, matchesRoutePattern, mergeRequestLoggerOptions, runWithIntegratedHandle, shouldInstrumentPath, toRouteAdapterOptions };

package/dist/toolkit/index.d.ts

@@ -11,31 +11,31 @@ import { ForkLifecycle as ForkLifecycle$1, RequestLogger } from "autotel";
  * omitted there is no keep-alive guarantee: on a freezing runtime the drain may
  * not finish, so callers that need delivery must supply `waitUntil`.
  */
-declare function extendDeferredDrain(drainPromise: Promise<unknown>, waitUntil?: (promise: Promise<unknown>) => void): void;
+export declare function extendDeferredDrain(drainPromise: Promise<unknown>, waitUntil?: (promise: Promise<unknown>) => void): void;
 //#endregion
 //#region src/toolkit/fork.d.ts
 /**
  * Wrap an existing request logger's `fork()` so adapter lifecycle hooks run
  * for background work spawned after the response returns.
  */
-declare function attachForkToLogger(logger: RequestLogger, lifecycle: ForkLifecycle$1): void;
+export declare function attachForkToLogger(logger: RequestLogger, lifecycle: ForkLifecycle$1): void;
 //#endregion
 //#region src/toolkit/stream-response.d.ts
 interface StreamCompleteMeta {
   status: number;
   error?: Error;
 }
-declare function isStreamingResponse(response: Response): boolean;
+export declare function isStreamingResponse(response: Response): boolean;
 /**
  * Whether framework integrations should defer wide-event emit until the response
  * body finishes. Static string/JSON bodies are excluded even though they use a
  * ReadableStream under the hood in the Fetch API.
  */
-declare function shouldDeferEmitForResponse(response: Response): boolean;
+export declare function shouldDeferEmitForResponse(response: Response): boolean;
 /**
  * Observe a streaming Response body and invoke `onComplete` once when the body
  * closes, errors, or is cancelled.
  */
-declare function bindStreamingResponseLifecycle(response: Response, onComplete: (meta: StreamCompleteMeta) => void | Promise<void>): Response;
+export declare function bindStreamingResponseLifecycle(response: Response, onComplete: (meta: StreamCompleteMeta) => void | Promise<void>): Response;
 //#endregion
-export { type BaseAdapterOptions, type ExtractedRequest, type ForkLifecycle, type FrameworkHandlerOptions, type FrameworkIntegrationHelpers, type FrameworkIntegrationSpec, type FrameworkRequestHandle, type IntegratedCompletionOptions, type MiddlewareLoggerOptions, type MiddlewareLoggerResult, type RouteAdapterOptions, type RouteFilterOptions, type RouteServiceConfig, type StreamCompleteMeta, type TailSamplingContext, applyLoggerEnrichment, attachForkToLogger, bindStreamingResponseLifecycle, buildTracedOptions, completeIntegratedRequest, createLoggerStorage, createMiddlewareLogger, createStorageForkLifecycle, defineFrameworkIntegration, extendDeferredDrain, getServiceForPath, isStreamingResponse, matchesRoutePattern, mergeRequestLoggerOptions, runWithIntegratedHandle, shouldDeferEmitForResponse, shouldInstrumentPath, toRouteAdapterOptions };
+export { type BaseAdapterOptions, type ExtractedRequest, type ForkLifecycle, type FrameworkHandlerOptions, type FrameworkIntegrationHelpers, type FrameworkIntegrationSpec, type FrameworkRequestHandle, type IntegratedCompletionOptions, type MiddlewareLoggerOptions, type MiddlewareLoggerResult, type RouteAdapterOptions, type RouteFilterOptions, type RouteServiceConfig, type StreamCompleteMeta, type TailSamplingContext, applyLoggerEnrichment, buildTracedOptions, completeIntegratedRequest, createLoggerStorage, createMiddlewareLogger, createStorageForkLifecycle, defineFrameworkIntegration, getServiceForPath, matchesRoutePattern, mergeRequestLoggerOptions, runWithIntegratedHandle, shouldInstrumentPath, toRouteAdapterOptions };

package/dist/toolkit/storage.d.cts

@@ -9,11 +9,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
  * on Cloudflare Workers / edge so `node:async_hooks` is not pulled through the
  * main `autotel-adapters/toolkit` barrel.
  */
-declare function createLoggerStorage(contextHint: string): {
+export declare function createLoggerStorage(contextHint: string): {
   storage: AsyncLocalStorage<RequestLogger>;
   useLogger: () => RequestLogger;
 };
 /** Bind forked loggers into the adapter's request-scoped storage. */
-declare function createStorageForkLifecycle(storage: AsyncLocalStorage<RequestLogger>): ForkLifecycle;
-//#endregion
-export { createLoggerStorage, createStorageForkLifecycle };
+export declare function createStorageForkLifecycle(storage: AsyncLocalStorage<RequestLogger>): ForkLifecycle;
+//#endregion

package/dist/toolkit/storage.d.ts

@@ -9,11 +9,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
  * on Cloudflare Workers / edge so `node:async_hooks` is not pulled through the
  * main `autotel-adapters/toolkit` barrel.
  */
-declare function createLoggerStorage(contextHint: string): {
+export declare function createLoggerStorage(contextHint: string): {
   storage: AsyncLocalStorage<RequestLogger>;
   useLogger: () => RequestLogger;
 };
 /** Bind forked loggers into the adapter's request-scoped storage. */
-declare function createStorageForkLifecycle(storage: AsyncLocalStorage<RequestLogger>): ForkLifecycle;
-//#endregion
-export { createLoggerStorage, createStorageForkLifecycle };
+export declare function createStorageForkLifecycle(storage: AsyncLocalStorage<RequestLogger>): ForkLifecycle;
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-adapters",
-  "version": "2.0.22",
+  "version": "2.0.23",
   "description": "Framework adapters and composable DX helpers for autotel",
   "license": "Apache-2.0",
   "type": "module",
@@ -86,14 +86,14 @@
     "NOTICE"
   ],
   "dependencies": {
-    "autotel": "7.9.0",
-    "autotel-edge": "5.1.1"
+    "autotel": "7.10.0",
+    "autotel-edge": "6.0.0"
   },
   "peerDependencies": {
-    "hono": ">=4.12.31",
-    "@tanstack/react-start": "^1.168.32",
-    "@tanstack/solid-start": "^1.168.32",
-    "next": ">=16.2.10",
+    "hono": ">=4.13.10",
+    "@tanstack/react-start": "^1.168.59",
+    "@tanstack/solid-start": "^1.168.56",
+    "next": ">=16.3.6",
     "h3": "^2.0.0",
     "nitropack": "^2.13.4",
     "rxjs": ">=7.8.2"
@@ -122,13 +122,13 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
-    "hono": "^4.12.32",
+    "@types/node": "^26.6.3",
+    "hono": "^4.13.10",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
-    "tsdown": "^0.22.14",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2"
   },
   "repository": {
     "type": "git",
@@ -139,7 +139,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "type-check": "tsc --noEmit",
-    "lint": "eslint src",
+    "lint": "oxlint -c oxlint.json --disable-nested-config src",
     "test": "vitest run",
     "clean": "rimraf dist"
   }