@bluelibs/runner 5.3.0 → 5.4.0

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 { run, globals } 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/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/universal-generic.d.ts

@@ -1,7 +1,10 @@
 import type { IAsyncLocalStorage, IPlatformAdapter } from "../types";
 export declare class GenericUniversalPlatformAdapter implements IPlatformAdapter {
     readonly id: "universal";
+    private alsClass;
+    private alsProbed;
     init(): Promise<void>;
+    private probeAsyncLocalStorage;
     onUncaughtException(handler: (error: any) => void): () => any;
     onUnhandledRejection(handler: (reason: any) => void): () => any;
     onShutdownSignal(handler: () => void): () => 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;

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

@@ -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;

package/dist/types/public.d.ts

@@ -205,8 +205,10 @@ export * as definitions from "./defs";
 export * from "./models";
 export * from "./globals/types";
 export * as Errors from "./errors";
+export { cancellationError } from "./errors";
 export { PlatformAdapter, setPlatform } from "./platform";
 export { RunnerError } from "./definers/defineError";
+export { LockableMap } from "./tools/LockableMap";
 export * from "./http-client";
 export * from "./http-fetch-tunnel.resource";
 export { Serializer, SymbolPolicy, SymbolPolicyErrorMessage, } from "./serializer";

package/dist/types/tools/LockableMap.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A Map that can be permanently locked to prevent further mutations.
+ *
+ * Before locking it behaves exactly like a regular `Map`.
+ * After `lock()` is called, any call to `set`, `delete` or `clear`
+ * throws immediately — enforcing immutability at the data-structure level.
+ */
+export declare class LockableMap<K, V> extends Map<K, V> {
+    #private;
+    constructor(name?: string);
+    /** Whether the map is currently locked. */
+    get locked(): boolean;
+    /** Permanently lock the map — no further mutations allowed. */
+    lock(): void;
+    /** @throws if the map is locked */
+    private throwIfLocked;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+}

package/dist/types/types/symbols.d.ts

@@ -5,7 +5,7 @@
  * @internal
  */
 export declare const symbolTask: unique symbol;
-/** Marks a task as a phantom task (no-op run; meant to be tunneled/routed). */
+/** Marks a task as a phantom task (throws when unrouted; meant to be tunneled/routed). */
 export declare const symbolPhantomTask: unique symbol;
 export declare const symbolResource: unique symbol;
 /** @internal Generic fork provenance metadata for definitions that support `.fork()` */

package/dist/types/types/task.d.ts

@@ -70,7 +70,7 @@ export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDepend
     tags: TTags;
 }
 export type AnyTask = ITask<any, any, any, any, any, any>;
-/** Narrowed type for phantom tasks (no-op run by default). */
+/** Narrowed type for phantom tasks (throws unless routed through a tunnel). */
 export type IPhantomTask<TInput = any, TResolved = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITask<TInput, Promise<TResolved>, TDependencies, TMeta, TTags, TMiddleware> & {
     [symbolPhantomTask]: true;
 };