@bluelibs/runner 5.3.0 → 5.5.0

package/dist/types/node/durable/store/MemoryStore.d.ts

@@ -9,6 +9,7 @@ export declare class MemoryStore implements IDurableStore {
     private timers;
     private schedules;
     private locks;
+    private pruneExpiredLocks;
     private getIdempotencyMapKey;
     getExecutionIdByIdempotencyKey(params: {
         taskId: string;
@@ -52,5 +53,6 @@ export declare class MemoryStore implements IDurableStore {
     listSchedules(): Promise<Schedule[]>;
     listActiveSchedules(): Promise<Schedule[]>;
     acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    renewLock(resource: string, lockId: string, ttlMs: number): Promise<boolean>;
     releaseLock(resource: string, lockId: string): Promise<void>;
 }

package/dist/types/node/durable/store/RedisStore.d.ts

@@ -85,5 +85,6 @@ export declare class RedisStore implements IDurableStore {
     listActiveSchedules(): Promise<Schedule[]>;
     acquireLock(resource: string, ttlMs: number): Promise<string | null>;
     releaseLock(resource: string, lockId: string): Promise<void>;
+    renewLock(resource: string, lockId: string, ttlMs: number): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/types/node/durable/tags/durableWorkflow.tag.d.ts

@@ -3,6 +3,11 @@ export interface DurableWorkflowTagConfig {
      * Optional domain/category to group workflows (eg. "orders", "billing").
      */
     category?: string;
+    /**
+     * Optional default input used by `durable.describe(task)` when no explicit
+     * input argument is provided.
+     */
+    defaults?: Record<string, unknown>;
     /**
      * Optional metadata for dashboards/tooling.
      */
@@ -11,4 +16,4 @@ export interface DurableWorkflowTagConfig {
 /**
  * Marks a task as a durable workflow for runtime discovery.
  */
-export declare const durableWorkflowTag: import("../..").ITag<DurableWorkflowTagConfig, void, void>;
+export declare const durableWorkflowTag: import("../../..").ITag<DurableWorkflowTagConfig, void, void>;

package/dist/types/node/exposure/allowList.d.ts

@@ -1,3 +1,4 @@
 import type { Store } from "../../models/Store";
+import type { Logger } from "../../models/Logger";
 import type { AllowListGuard } from "./types";
-export declare function createAllowListGuard(store: Store, allowOpen?: boolean): AllowListGuard;
+export declare function createAllowListGuard(store: Store, allowOpen?: boolean, logger?: Logger): AllowListGuard;

package/dist/types/node/exposure/handlers/contextWrapper.d.ts

@@ -8,11 +8,15 @@ export interface ExposureContextDeps {
     };
     serializer: SerializerLike;
 }
+interface AsyncContextHydrationOptions {
+    allowAsyncContext?: boolean;
+}
 /**
  * Builds a composed provider: first user async contexts (if any), then exposure context
  */
-export declare const withExposureContext: <T>(req: IncomingMessage, res: ServerResponse, controller: AbortController, deps: ExposureContextDeps, fn: () => Promise<T>) => Promise<T>;
+export declare const withExposureContext: <T>(req: IncomingMessage, res: ServerResponse, controller: AbortController, deps: ExposureContextDeps, fn: () => Promise<T>, options?: AsyncContextHydrationOptions) => Promise<T>;
 /**
  * Builds user async contexts (if any), without exposure context (for events)
  */
-export declare const withUserContexts: <T>(req: IncomingMessage, deps: Pick<ExposureContextDeps, "store" | "serializer">, fn: () => Promise<T>) => Promise<T>;
+export declare const withUserContexts: <T>(req: IncomingMessage, deps: Pick<ExposureContextDeps, "store" | "serializer">, fn: () => Promise<T>, options?: AsyncContextHydrationOptions) => Promise<T>;
+export {};

package/dist/types/node/exposure/handlers/errorHandlers.d.ts

@@ -19,5 +19,6 @@ export interface HandleRequestErrorOptions {
     cors?: NodeExposureHttpCorsConfig;
     serializer: SerializerLike;
     logKey: ExposureErrorLogKey;
+    requestId?: string;
 }
 export declare const handleRequestError: (options: HandleRequestErrorOptions) => void;

package/dist/types/node/exposure/handlers/eventHandler.d.ts

@@ -15,6 +15,7 @@ interface EventHandlerDeps {
             maxSize?: number;
         };
     };
+    allowAsyncContext?: (eventId: string) => boolean;
 }
 export declare const createEventHandler: (deps: EventHandlerDeps) => (req: IncomingMessage, res: ServerResponse, eventId: string) => Promise<void>;
 export {};

package/dist/types/node/exposure/handlers/taskHandler.d.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "http";
 import type { SerializerLike } from "../../../serializer";
 import type { Authenticator, AllowListGuard } from "../types";
 import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "../resourceTypes";
+import type { MultipartLimits } from "../multipart";
 interface TaskHandlerDeps {
     store: NodeExposureDeps["store"];
     taskRunner: NodeExposureDeps["taskRunner"];
@@ -17,8 +18,9 @@ interface TaskHandlerDeps {
         json?: {
             maxSize?: number;
         };
-        multipart?: any;
+        multipart?: MultipartLimits;
     };
+    allowAsyncContext?: (taskId: string) => boolean;
 }
 export declare const createTaskHandler: (deps: TaskHandlerDeps) => (req: IncomingMessage, res: ServerResponse, taskId: string) => Promise<void>;
 export {};

package/dist/types/node/exposure/logging.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from "../../models/Logger";
 export declare function safeLogError(logger: Logger, message: string, data: Record<string, unknown>): void;
 export declare function safeLogInfo(logger: Logger, message: string, data: Record<string, unknown>): void;
+export declare function safeLogWarn(logger: Logger, message: string, data: Record<string, unknown>): void;
 export declare function errorMessage(error: unknown): string;

package/dist/types/node/exposure/requestContext.d.ts

@@ -8,7 +8,7 @@ export interface ExposureRequestContextValue {
     method?: string;
     signal: AbortSignal;
 }
-export declare const ExposureRequestContext: import("..").IAsyncContext<ExposureRequestContextValue>;
+export declare const ExposureRequestContext: import("../..").IAsyncContext<ExposureRequestContextValue>;
 export declare function useExposureContext(): ExposureRequestContextValue;
 /**
  * Checks if the exposure request context is currently available without throwing an error.

package/dist/types/node/exposure/requestHandlers.d.ts

@@ -3,6 +3,7 @@ import type { SerializerLike } from "../../serializer";
 import type { Authenticator, AllowListGuard, RequestHandler } from "./types";
 import type { ExposureRouter } from "./router";
 import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "./resourceTypes";
+import type { MultipartLimits } from "./multipart";
 export interface RequestProcessingDeps {
     store: NodeExposureDeps["store"];
     taskRunner: NodeExposureDeps["taskRunner"];
@@ -17,8 +18,9 @@ export interface RequestProcessingDeps {
         json?: {
             maxSize?: number;
         };
-        multipart?: any;
+        multipart?: MultipartLimits;
     };
+    disableDiscovery?: boolean;
 }
 export interface NodeExposureRequestHandlers {
     handleTask: (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/types/node/exposure/requestIdentity.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "http";
+export declare function getRequestId(req: IncomingMessage): string | undefined;
+export declare function ensureRequestId(req: IncomingMessage, res: ServerResponse): string;

package/dist/types/node/exposure/resource.d.ts

@@ -1,12 +1,12 @@
 import type { NodeExposureConfig } from "./resourceTypes";
 export type { NodeExposureHttpAuthConfig } from "./authenticator";
-export declare const nodeExposure: import("..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
-    store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    logger: import("..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    serializer: import("..").IResource<void, Promise<import("..").SerializerLike>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const nodeExposure: import("../..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
+    store: import("../..").IResource<void, Promise<import("..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    serializer: import("../..").IResource<void, Promise<import("../..").SerializerLike>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }, any, {
     title: string;
     description: string;
-}, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/exposure/resourceTypes.d.ts

@@ -33,6 +33,12 @@ export interface NodeExposureHttpConfig {
      * When true and no server-mode tunnel is registered, exposure is open.
      */
     dangerouslyAllowOpenExposure?: boolean;
+    /**
+     * Disable the discovery endpoint that enumerates registered task/event IDs.
+     * When true, the /__runner/discovery endpoint returns 404.
+     * @default false
+     */
+    disableDiscovery?: boolean;
 }
 export interface NodeExposureConfig {
     http?: NodeExposureHttpConfig;

package/dist/types/node/exposure/serverLifecycle.d.ts

@@ -1,10 +1,12 @@
 import * as http from "http";
 import type { RequestHandler } from "./types";
 import type { Logger } from "../../models/Logger";
+import type { NodeExposureHttpCorsConfig } from "./resourceTypes";
 export declare function makeRequestListener(options: {
     handler: RequestHandler;
     respondOnMiss: boolean;
     logger: Logger;
+    cors?: NodeExposureHttpCorsConfig;
 }): http.RequestListener;
 export declare function startHttpServer(server: http.Server, listen: {
     port: number;

package/dist/types/node/http/http-mixed-client.factory.resource.d.ts

@@ -13,5 +13,5 @@ export interface HttpMixedClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
-export declare const httpMixedClientFactory: import("..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpMixedClientFactory: import("../..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { MixedHttpClient };

package/dist/types/node/http/http-smart-client.factory.resource.d.ts

@@ -12,5 +12,5 @@ export interface HttpSmartClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
-export declare const httpSmartClientFactory: import("..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpSmartClientFactory: import("../..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { HttpSmartClient };

package/dist/types/node/node.d.ts

@@ -1,6 +1,4 @@
-export * from "../index";
-import type { RunResult } from "../models/RunResult";
-import type { SerializerLike } from "../serializer";
+export * from "../public";
 export { nodeExposure } from "./exposure";
 export { hasExposureContext, useExposureContext, } from "./exposure/requestContext";
 export type * from "./exposure/resourceTypes";
@@ -10,184 +8,3 @@ export { readInputFileToBuffer, writeInputFileToPath } from "./files";
 export { createHttpSmartClient, createHttpMixedClient } from "./http";
 export type { HttpSmartClient, HttpSmartClientAuthConfig, HttpSmartClientConfig, MixedHttpClient, MixedHttpClientAuthConfig, MixedHttpClientConfig, Readable, } from "./http";
 export * from "./durable";
-export declare const globals: {
-    resources: {
-        httpSmartClientFactory: import("./node").IResource<void, Promise<import("./http").HttpSmartClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        httpMixedClientFactory: import("./node").IResource<void, Promise<import("./http").HttpMixedClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        middlewareManager: import("./node").IResource<void, Promise<import("./node").MiddlewareManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        eventManager: import("./node").IResource<void, Promise<import("./node").EventManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        logger: import("./node").IResource<void, Promise<import("./node").Logger>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
-            map: Map<string, import("./node").ICacheInstance>;
-            cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
-            defaultOptions: any;
-        }>, {
-            cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
-        }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        queue: import("./node").IResource<void, Promise<{
-            map: Map<string, import("./node").Queue>;
-            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-        }>, {}, {
-            map: Map<string, import("./node").Queue>;
-        }, {
-            title: string;
-            description: string;
-        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        httpClientFactory: import("./node").IResource<void, Promise<import("./node").HttpClientFactory>, {
-            serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        }, any, {
-            title: string;
-            description: string;
-        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        rateLimit: import("./node").IResource<void, Promise<{
-            states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        circuitBreaker: import("./node").IResource<void, Promise<{
-            statusMap: Map<string, import("./node").CircuitBreakerStatus>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        temporal: import("./node").IResource<void, Promise<{
-            debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-            throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        concurrency: import("./node").IResource<void, Promise<{
-            semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
-            semaphoresByKey: Map<string, {
-                semaphore: import("./node").Semaphore;
-                limit: number;
-            }>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-    };
-    events: {
-        readonly ready: import("./node").IEvent<void>;
-    };
-    middleware: {
-        requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
-        task: {
-            requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
-            cache: import("./node").ITaskMiddleware<any, void, void, {
-                cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
-                    map: Map<string, import("./node").ICacheInstance>;
-                    cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
-                    defaultOptions: any;
-                }>, {
-                    cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
-                }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly hit: import("./node").JournalKey<boolean>;
-                };
-            };
-            concurrency: import("./node").ITaskMiddleware<import("./node").ConcurrencyMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
-                    semaphoresByKey: Map<string, {
-                        semaphore: import("./node").Semaphore;
-                        limit: number;
-                    }>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            debounce: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            throttle: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            fallback: import("./node").ITaskMiddleware<import("./node").FallbackMiddlewareConfig, void, void, {
-                taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly active: import("./node").JournalKey<boolean>;
-                    readonly error: import("./node").JournalKey<Error>;
-                };
-            };
-            rateLimit: import("./node").ITaskMiddleware<import("./node").RateLimitMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly remaining: import("./node").JournalKey<number>;
-                    readonly resetTime: import("./node").JournalKey<number>;
-                    readonly limit: import("./node").JournalKey<number>;
-                };
-            };
-            retry: import("./node").ITaskMiddleware<import("./node").RetryMiddlewareConfig, void, void, any> & {
-                journalKeys: {
-                    readonly attempt: import("./node").JournalKey<number>;
-                    readonly lastError: import("./node").JournalKey<Error>;
-                };
-            };
-            timeout: import("./node").ITaskMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any> & {
-                journalKeys: {
-                    readonly abortController: import("./node").JournalKey<AbortController>;
-                };
-            };
-            circuitBreaker: import("./node").ITaskMiddleware<import("./node").CircuitBreakerMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    statusMap: Map<string, import("./node").CircuitBreakerStatus>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly state: import("./node").JournalKey<import("./node").CircuitBreakerState>;
-                    readonly failures: import("./node").JournalKey<number>;
-                };
-            };
-        };
-        resource: {
-            retry: import("./node").IResourceMiddleware<import("./node").RetryMiddlewareConfig, void, void, any>;
-            timeout: import("./node").IResourceMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any>;
-        };
-    };
-    tags: {
-        system: import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        excludeFromGlobalHooks: import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        debug: import("./node").ITag<import("./node").DebugFriendlyConfig, void, void>;
-        tunnel: import("./node").ITag<void, void, import("./node").TunnelRunner>;
-        tunnelPolicy: import("./node").ITag<import("./node").TunnelTaskMiddlewarePolicyConfig, void, void>;
-        authValidator: import("./node").ITag<void, void, void>;
-    };
-    tunnels: Readonly<{
-        http: Readonly<{
-            createClient(cfg: import("./node").HttpCreateClientConfig): import("./node").ExposureFetchClient;
-        }>;
-    }>;
-    debug: {
-        levels: {
-            normal: import("./node").DebugConfig;
-            verbose: import("./node").DebugConfig;
-        };
-    };
-};
-export declare function run(root: any, config?: any): Promise<RunResult<any>>;

package/dist/types/node/tunnel/allowlist.d.ts

@@ -3,5 +3,14 @@ export interface TunnelAllowList {
     enabled: boolean;
     taskIds: Set<string>;
     eventIds: Set<string>;
+    taskAcceptsAsyncContext: Map<string, boolean>;
+    eventAcceptsAsyncContext: Map<string, boolean>;
 }
-export declare function computeAllowList(store: Store): TunnelAllowList;
+export interface AllowListSelectorErrorInfo {
+    selectorKind: "task" | "event";
+    candidateId: string;
+    tunnelResourceId: string;
+    error: unknown;
+}
+export type AllowListSelectorErrorReporter = (info: AllowListSelectorErrorInfo) => void;
+export declare function computeAllowList(store: Store, onSelectorError?: AllowListSelectorErrorReporter): TunnelAllowList;

package/dist/types/platform/adapters/browser.d.ts

@@ -2,7 +2,7 @@ import type { IAsyncLocalStorage, IPlatformAdapter, PlatformId } from "../types"
 export declare class BrowserPlatformAdapter implements IPlatformAdapter {
     readonly id: PlatformId;
     init(): Promise<void>;
-    onUncaughtException(handler: (error: Error) => void): () => void | undefined;
+    onUncaughtException(handler: (error: unknown) => void): () => void | undefined;
     onUnhandledRejection(handler: (reason: unknown) => void): () => void | undefined;
     onShutdownSignal(handler: () => void): () => void;
     exit(): void;

package/dist/types/platform/adapters/edge.d.ts

@@ -1,5 +1,22 @@
+import type { IAsyncLocalStorage } from "../types";
 import { BrowserPlatformAdapter } from "./browser";
+/**
+ * Edge runtimes (workers) are closer to browsers but may support
+ * AsyncLocalStorage via the `node:async_hooks` compat layer
+ * (e.g. Cloudflare Workers, Vercel Edge).
+ */
 export declare class EdgePlatformAdapter extends BrowserPlatformAdapter {
     readonly id: "edge";
+    private alsClass;
+    private alsProbed;
+    init(): Promise<void>;
+    /**
+     * Attempt to discover AsyncLocalStorage from the runtime.
+     * Checks globalThis first, then tries `import("node:async_hooks")`.
+     */
+    private probeGlobalAsyncLocalStorage;
+    private probeAsyncLocalStorage;
     onShutdownSignal(_handler: () => void): () => void;
+    hasAsyncLocalStorage(): boolean;
+    createAsyncLocalStorage<T>(): IAsyncLocalStorage<T>;
 }

package/dist/types/platform/adapters/node-als.d.ts

@@ -1 +1 @@
-export declare function loadAsyncLocalStorageClass(): Promise<typeof import("async_hooks").AsyncLocalStorage>;
+export declare function loadAsyncLocalStorageClass(): Promise<typeof import("node:async_hooks").AsyncLocalStorage>;

package/dist/types/platform/adapters/node.d.ts

@@ -3,7 +3,7 @@ export declare class NodePlatformAdapter implements IPlatformAdapter {
     readonly id: "node";
     private alsClass;
     init(): Promise<void>;
-    onUncaughtException(handler: (error: Error) => void): () => NodeJS.Process;
+    onUncaughtException(handler: (error: unknown) => void): () => NodeJS.Process;
     onUnhandledRejection(handler: (reason: unknown) => void): () => NodeJS.Process;
     onShutdownSignal(handler: () => void): () => void;
     exit(code: number): void;

package/dist/types/platform/adapters/universal-generic.d.ts

@@ -1,9 +1,12 @@
 import type { IAsyncLocalStorage, IPlatformAdapter } from "../types";
 export declare class GenericUniversalPlatformAdapter implements IPlatformAdapter {
     readonly id: "universal";
+    private alsClass;
+    private alsProbed;
     init(): Promise<void>;
-    onUncaughtException(handler: (error: any) => void): () => any;
-    onUnhandledRejection(handler: (reason: any) => void): () => any;
+    private probeAsyncLocalStorage;
+    onUncaughtException(handler: (error: unknown) => void): () => void | undefined;
+    onUnhandledRejection(handler: (reason: unknown) => void): () => void | undefined;
     onShutdownSignal(handler: () => void): () => void;
     exit(): void;
     getEnv(key: string): string | undefined;

package/dist/types/platform/adapters/universal.d.ts

@@ -6,7 +6,7 @@ export declare class UniversalPlatformAdapter implements IPlatformAdapter {
     init(): Promise<void>;
     private ensureInner;
     private get;
-    onUncaughtException(handler: (error: Error) => void): () => void;
+    onUncaughtException(handler: (error: unknown) => void): () => void;
     onUnhandledRejection(handler: (reason: unknown) => void): () => void;
     onShutdownSignal(handler: () => void): () => void;
     exit(code: number): void;

package/dist/types/platform/index.d.ts

@@ -8,6 +8,7 @@ export declare function getDetectedEnvironment(): PlatformId;
 export declare function isNode(): boolean;
 export declare function isBrowser(): boolean;
 export declare function isUniversal(): boolean;
+export declare function isEdge(): boolean;
 export type { IPlatformAdapter, IAsyncLocalStorage, PlatformId, PlatformSetTimeout, PlatformClearTimeout, } from "./types";
 export declare class PlatformAdapter implements IPlatformAdapter {
     private inner;
@@ -17,8 +18,8 @@ export declare class PlatformAdapter implements IPlatformAdapter {
     readonly clearTimeout: PlatformClearTimeout;
     constructor(env?: PlatformId);
     init(): Promise<void>;
-    onUncaughtException(handler: (error: any) => void): () => void;
-    onUnhandledRejection(handler: (reason: any) => void): () => void;
+    onUncaughtException(handler: (error: unknown) => void): () => void;
+    onUnhandledRejection(handler: (reason: unknown) => void): () => void;
     onShutdownSignal(handler: () => void): () => void;
     exit(code: number): void;
     getEnv(key: string): string | undefined;

package/dist/types/platform/types.d.ts

@@ -7,7 +7,7 @@ export type PlatformSetTimeout = (...args: Parameters<typeof globalThis.setTimeo
 export type PlatformClearTimeout = (timeout: ReturnType<PlatformSetTimeout>) => void;
 export interface IPlatformAdapter {
     readonly id: PlatformId;
-    onUncaughtException(handler: (error: Error) => void): () => void;
+    onUncaughtException(handler: (error: unknown) => void): () => void;
     onUnhandledRejection(handler: (reason: unknown) => void): () => void;
     onShutdownSignal(handler: () => void): () => void;
     exit(code: number): void;
@@ -23,9 +23,15 @@ export interface IAsyncLocalStorage<T> {
     run<R>(store: T, callback: () => R): R;
 }
 /**
- * Utility functions for environment detection
+ * Backward-compatible utility functions retained for consumers
+ * importing environment guards from `platform/types`.
  */
 export declare function isNode(): boolean;
 export declare function isBrowser(): boolean;
+/**
+ * Legacy alias kept for compatibility.
+ * Worker-like runtimes are now modeled under the "edge" platform id.
+ */
 export declare function isWebWorker(): boolean;
+export declare function isEdge(): boolean;
 export declare function isUniversal(): boolean;