@bluelibs/runner 5.4.0 → 5.5.0

package/dist/types/public.d.ts

@@ -13,23 +13,114 @@ declare const globals: {
         readonly eventManager: import("./defs").IResource<void, Promise<import("./models").EventManager>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly taskRunner: import("./defs").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly logger: import("./defs").IResource<void, Promise<import("./models").Logger>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+        readonly debug: import("./defs").IResource<import("./public").DebugFriendlyConfig, Promise<any>, {}, any, {
+            title: string;
+            description: string;
+        }, import("./defs").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly serializer: import("./defs").IResource<void, Promise<import("./serializer").SerializerLike>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly cache: import("./defs").IResource<import("./public").CacheResourceConfig, Promise<{
             map: Map<string, import("./defs").ICacheInstance>;
-            cacheFactoryTask: import("./defs").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./defs").ICacheInstance>>;
-            defaultOptions: any;
+            pendingCreates: Map<string, Promise<import("./defs").ICacheInstance>>;
+            cacheFactoryTask: import("./defs").TaskDependencyWithIntercept<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>>;
+            defaultOptions: {
+                ttl: number;
+                max: number;
+                ttlAutopurge: boolean;
+            } | {
+                max: import("lru-cache/raw").LRUCache.Count;
+                ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                ttlAutopurge: boolean;
+                updateAgeOnGet?: boolean | undefined;
+                updateAgeOnHas?: boolean | undefined;
+                allowStale?: boolean | undefined;
+                dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                noDisposeOnSet?: boolean | undefined;
+                noUpdateTTL?: boolean | undefined;
+                maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                noDeleteOnFetchRejection?: boolean | undefined;
+                noDeleteOnStaleGet?: boolean | undefined;
+                allowStaleOnFetchRejection?: boolean | undefined;
+                allowStaleOnFetchAbort?: boolean | undefined;
+                ignoreFetchAbort?: boolean | undefined;
+                perf?: import("lru-cache/raw").Perf | undefined;
+            } | {
+                maxSize?: number | undefined;
+                max: import("lru-cache/raw").LRUCache.Count;
+                ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                ttlAutopurge: boolean;
+                updateAgeOnGet?: boolean | undefined;
+                updateAgeOnHas?: boolean | undefined;
+                allowStale?: boolean | undefined;
+                dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                noDisposeOnSet?: boolean | undefined;
+                noUpdateTTL?: boolean | undefined;
+                maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                noDeleteOnFetchRejection?: boolean | undefined;
+                noDeleteOnStaleGet?: boolean | undefined;
+                allowStaleOnFetchRejection?: boolean | undefined;
+                allowStaleOnFetchAbort?: boolean | undefined;
+                ignoreFetchAbort?: boolean | undefined;
+                perf?: import("lru-cache/raw").Perf | undefined;
+            } | {
+                ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                ttlAutopurge: boolean;
+                max: import("lru-cache/raw").LRUCache.Count;
+                ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                updateAgeOnGet?: boolean | undefined;
+                updateAgeOnHas?: boolean | undefined;
+                allowStale?: boolean | undefined;
+                dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                noDisposeOnSet?: boolean | undefined;
+                noUpdateTTL?: boolean | undefined;
+                maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                noDeleteOnFetchRejection?: boolean | undefined;
+                noDeleteOnStaleGet?: boolean | undefined;
+                allowStaleOnFetchRejection?: boolean | undefined;
+                allowStaleOnFetchAbort?: boolean | undefined;
+                ignoreFetchAbort?: boolean | undefined;
+                perf?: import("lru-cache/raw").Perf | undefined;
+            };
         }>, {
-            cacheFactoryTask: import("./defs").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./defs").ICacheInstance>, any, any, import("./defs").TagType[], import("./defs").TaskMiddlewareAttachmentType[]>;
+            cacheFactoryTask: import("./defs").ITask<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>, any, any, import("./defs").TagType[], import("./defs").TaskMiddlewareAttachmentType[]>;
+        }, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+        readonly cron: import("./defs").IResource<void, Promise<import("./public").CronResourceValue>, import("./defs").DependencyMapType & {
+            store: typeof import("./globals/globalResources").store;
+            logger: typeof import("./globals/resources/logger.resource").loggerResource;
+            taskRunner: typeof import("./globals/resources/taskRunner.resource").taskRunnerResource;
         }, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly queue: import("./defs").IResource<void, Promise<{
             map: Map<string, import("./models").Queue>;
             run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
         }>, {}, {
+            disposed: boolean;
             map: Map<string, import("./models").Queue>;
+            cleanupTimers: Map<string, NodeJS.Timeout>;
         }, {
             title: string;
             description: string;
         }, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+        readonly runtime: import("./defs").IResource<void, Promise<import("./models").RunResult<unknown>>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly httpClientFactory: import("./defs").IResource<void, Promise<import("./public").HttpClientFactory>, {
             serializer: import("./defs").IResource<void, Promise<import("./serializer").SerializerLike>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
             store: import("./defs").IResource<void, Promise<import("./models").Store>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
@@ -47,10 +138,7 @@ declare const globals: {
         }>, {}, any, any, import("./defs").ITag<{
             metadata?: Record<string, any>;
         }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-        readonly temporal: import("./defs").IResource<void, Promise<{
-            debounceStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").DebounceState>;
-            throttleStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").ThrottleState>;
-        }>, {}, any, any, import("./defs").ITag<{
+        readonly temporal: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
             metadata?: Record<string, any>;
         }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
         readonly concurrency: import("./defs").IResource<void, Promise<{
@@ -59,6 +147,7 @@ declare const globals: {
                 semaphore: import("./models").Semaphore;
                 limit: number;
             }>;
+            semaphores: Set<import("./models").Semaphore>;
         }>, {}, any, any, import("./defs").ITag<{
             metadata?: Record<string, any>;
         }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
@@ -67,13 +156,92 @@ declare const globals: {
         requireContext: import("./defs").ITaskMiddleware<import("./public").RequireContextMiddlewareConfig, void, void, any>;
         task: {
             requireContext: import("./defs").ITaskMiddleware<import("./public").RequireContextMiddlewareConfig, void, void, any>;
-            cache: import("./defs").ITaskMiddleware<any, void, void, {
+            cache: import("./defs").ITaskMiddleware<(Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>) & {
+                keyBuilder?: (taskId: string, input: unknown) => string;
+            }, void, void, {
                 cache: import("./defs").IResource<import("./public").CacheResourceConfig, Promise<{
                     map: Map<string, import("./defs").ICacheInstance>;
-                    cacheFactoryTask: import("./defs").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./defs").ICacheInstance>>;
-                    defaultOptions: any;
+                    pendingCreates: Map<string, Promise<import("./defs").ICacheInstance>>;
+                    cacheFactoryTask: import("./defs").TaskDependencyWithIntercept<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>>;
+                    defaultOptions: {
+                        ttl: number;
+                        max: number;
+                        ttlAutopurge: boolean;
+                    } | {
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        ttlAutopurge: boolean;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    } | {
+                        maxSize?: number | undefined;
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        ttlAutopurge: boolean;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    } | {
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlAutopurge: boolean;
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    };
                 }>, {
-                    cacheFactoryTask: import("./defs").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./defs").ICacheInstance>, any, any, import("./defs").TagType[], import("./defs").TaskMiddlewareAttachmentType[]>;
+                    cacheFactoryTask: import("./defs").ITask<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>, any, any, import("./defs").TagType[], import("./defs").TaskMiddlewareAttachmentType[]>;
                 }, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
             }> & {
                 journalKeys: {
@@ -87,25 +255,188 @@ declare const globals: {
                         semaphore: import("./models").Semaphore;
                         limit: number;
                     }>;
+                    semaphores: Set<import("./models").Semaphore>;
                 }>, {}, any, any, import("./defs").ITag<{
                     metadata?: Record<string, any>;
                 }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
             }>;
             debounce: import("./defs").ITaskMiddleware<import("./public").TemporalMiddlewareConfig, void, void, {
-                state: import("./defs").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").DebounceState>;
-                    throttleStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").ThrottleState>;
-                }>, {}, any, any, import("./defs").ITag<{
+                state: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
                     metadata?: Record<string, any>;
                 }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
             }>;
             throttle: import("./defs").ITaskMiddleware<import("./public").TemporalMiddlewareConfig, void, void, {
+                state: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            fallback: import("./defs").ITaskMiddleware<import("./public").FallbackMiddlewareConfig, void, void, {
+                taskRunner: import("./defs").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly active: import("./public-types").JournalKey<boolean>;
+                    readonly error: import("./public-types").JournalKey<Error>;
+                };
+            };
+            rateLimit: import("./defs").ITaskMiddleware<import("./public").RateLimitMiddlewareConfig, void, void, {
                 state: import("./defs").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").DebounceState>;
-                    throttleStates: WeakMap<import("./public").TemporalMiddlewareConfig, import("./public").ThrottleState>;
+                    states: WeakMap<import("./public").RateLimitMiddlewareConfig, import("./public").RateLimitState>;
                 }>, {}, any, any, import("./defs").ITag<{
                     metadata?: Record<string, any>;
                 }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly remaining: import("./public-types").JournalKey<number>;
+                    readonly resetTime: import("./public-types").JournalKey<number>;
+                    readonly limit: import("./public-types").JournalKey<number>;
+                };
+            };
+            retry: import("./defs").ITaskMiddleware<import("./public").RetryMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly attempt: import("./public-types").JournalKey<number>;
+                    readonly lastError: import("./public-types").JournalKey<Error>;
+                };
+            };
+            timeout: import("./defs").ITaskMiddleware<import("./public").TimeoutMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly abortController: import("./public-types").JournalKey<AbortController>;
+                };
+            };
+            circuitBreaker: import("./defs").ITaskMiddleware<import("./public").CircuitBreakerMiddlewareConfig, void, void, {
+                state: import("./defs").IResource<void, Promise<{
+                    statusMap: Map<string, import("./public").CircuitBreakerStatus>;
+                }>, {}, any, any, import("./defs").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly state: import("./public-types").JournalKey<import("./public").CircuitBreakerState>;
+                    readonly failures: import("./public-types").JournalKey<number>;
+                };
+            };
+        };
+        resource: {
+            retry: import("./defs").IResourceMiddleware<import("./public").RetryMiddlewareConfig, void, void, any>;
+            timeout: import("./defs").IResourceMiddleware<import("./public").TimeoutMiddlewareConfig, void, void, any>;
+        };
+    };
+    middlewares: {
+        requireContext: import("./defs").ITaskMiddleware<import("./public").RequireContextMiddlewareConfig, void, void, any>;
+        task: {
+            requireContext: import("./defs").ITaskMiddleware<import("./public").RequireContextMiddlewareConfig, void, void, any>;
+            cache: import("./defs").ITaskMiddleware<(Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>) & {
+                keyBuilder?: (taskId: string, input: unknown) => string;
+            }, void, void, {
+                cache: import("./defs").IResource<import("./public").CacheResourceConfig, Promise<{
+                    map: Map<string, import("./defs").ICacheInstance>;
+                    pendingCreates: Map<string, Promise<import("./defs").ICacheInstance>>;
+                    cacheFactoryTask: import("./defs").TaskDependencyWithIntercept<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>>;
+                    defaultOptions: {
+                        ttl: number;
+                        max: number;
+                        ttlAutopurge: boolean;
+                    } | {
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        ttlAutopurge: boolean;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    } | {
+                        maxSize?: number | undefined;
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        ttlAutopurge: boolean;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    } | {
+                        ttl: import("lru-cache/raw").LRUCache.Milliseconds;
+                        ttlAutopurge: boolean;
+                        max: import("lru-cache/raw").LRUCache.Count;
+                        ttlResolution?: import("lru-cache/raw").LRUCache.Milliseconds | undefined;
+                        updateAgeOnGet?: boolean | undefined;
+                        updateAgeOnHas?: boolean | undefined;
+                        allowStale?: boolean | undefined;
+                        dispose?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        onInsert?: import("lru-cache/raw").LRUCache.Inserter<string, {}> | undefined;
+                        disposeAfter?: import("lru-cache/raw").LRUCache.Disposer<string, {}> | undefined;
+                        noDisposeOnSet?: boolean | undefined;
+                        noUpdateTTL?: boolean | undefined;
+                        maxSize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        maxEntrySize?: import("lru-cache/raw").LRUCache.Size | undefined;
+                        sizeCalculation?: import("lru-cache/raw").LRUCache.SizeCalculator<string, {}> | undefined;
+                        fetchMethod?: import("lru-cache/raw").LRUCache.Fetcher<string, {}, unknown> | undefined;
+                        memoMethod?: import("lru-cache/raw").LRUCache.Memoizer<string, {}, unknown> | undefined;
+                        noDeleteOnFetchRejection?: boolean | undefined;
+                        noDeleteOnStaleGet?: boolean | undefined;
+                        allowStaleOnFetchRejection?: boolean | undefined;
+                        allowStaleOnFetchAbort?: boolean | undefined;
+                        ignoreFetchAbort?: boolean | undefined;
+                        perf?: import("lru-cache/raw").Perf | undefined;
+                    };
+                }>, {
+                    cacheFactoryTask: import("./defs").ITask<Partial<import("lru-cache/raw").LRUCache.OptionsMaxLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsSizeLimit<string, {}, unknown>> | Partial<import("lru-cache/raw").LRUCache.OptionsTTLLimit<string, {}, unknown>>, Promise<import("./defs").ICacheInstance>, any, any, import("./defs").TagType[], import("./defs").TaskMiddlewareAttachmentType[]>;
+                }, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly hit: import("./public-types").JournalKey<boolean>;
+                };
+            };
+            concurrency: import("./defs").ITaskMiddleware<import("./public").ConcurrencyMiddlewareConfig, void, void, {
+                state: import("./defs").IResource<void, Promise<{
+                    semaphoresByConfig: WeakMap<import("./public").ConcurrencyMiddlewareConfig, import("./models").Semaphore>;
+                    semaphoresByKey: Map<string, {
+                        semaphore: import("./models").Semaphore;
+                        limit: number;
+                    }>;
+                    semaphores: Set<import("./models").Semaphore>;
+                }>, {}, any, any, import("./defs").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            debounce: import("./defs").ITaskMiddleware<import("./public").TemporalMiddlewareConfig, void, void, {
+                state: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            throttle: import("./defs").ITaskMiddleware<import("./public").TemporalMiddlewareConfig, void, void, {
+                state: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
             }>;
             fallback: import("./defs").ITaskMiddleware<import("./public").FallbackMiddlewareConfig, void, void, {
                 taskRunner: import("./defs").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import("./defs").TagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
@@ -165,9 +496,12 @@ declare const globals: {
             metadata?: Record<string, any>;
         }, void, void>;
         debug: import("./defs").ITag<import("./public").DebugFriendlyConfig, void, void>;
+        cron: import("./defs").ITag<import("./public").CronTagConfig, void, void>;
         tunnel: import("./defs").ITag<void, void, import("./public").TunnelRunner>;
-        tunnelPolicy: import("./defs").ITag<import("./public").TunnelTaskMiddlewarePolicyConfig, void, void>;
+        tunnelTaskPolicy: import("./defs").ITag<import("./public").TunnelTaskMiddlewarePolicyConfig, void, void>;
         authValidator: import("./defs").ITag<void, void, void>;
+    } & {
+        tunnelPolicy: typeof import("./globals/resources/tunnel/tunnel.policy.tag").tunnelTaskPolicyTag;
     };
     tunnels: Readonly<{
         http: Readonly<{
@@ -185,6 +519,24 @@ export { globals };
 export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineAsyncContext as asyncContext, defineTag as tag, defineOverride as override, defineHook as hook, run, createTestResource, };
 declare const createContext: typeof oldCreateContext;
 export { createContext };
+/**
+ * The unified fluent builder namespace for creating Runner components.
+ *
+ * @example
+ * ```ts
+ * import { r, run } from "@bluelibs/runner";
+ *
+ * const greet = r.task("app.tasks.greet")
+ *   .inputSchema<{ name: string }>({ parse: (v) => v })
+ *   .run(async (input) => `Hello, ${input.name}!`)
+ *   .build();
+ *
+ * const app = r.resource("app").register([greet]).build();
+ * const runtime = await run(app);
+ * const msg = await runtime.runTask(greet, { name: "Ada" });
+ * await runtime.dispose();
+ * ```
+ */
 export declare const r: Readonly<{
     resource: typeof import("./definers/builders/resource").resourceBuilder;
     task: import("./public-types").TaskBuilderWithPhantom;
@@ -194,7 +546,10 @@ export declare const r: Readonly<{
     override: typeof overrideBuilder;
     asyncContext: typeof import("./definers/builders/asyncContext").asyncContextBuilder;
     error: typeof import("./definers/builders/error").errorBuilder & {
-        is: (error: unknown) => error is import("./public").RunnerError;
+        is: {
+            (error: unknown): error is import("./public").RunnerError;
+            (error: unknown, partialData: Partial<import("./defs").DefaultErrorType>): error is import("./public").RunnerError;
+        };
     };
     middleware: Readonly<{
         task: typeof import("./definers/builders/middleware").taskMiddlewareBuilder;
@@ -210,6 +565,5 @@ 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";
 export { journal } from "./models/ExecutionJournal";

package/dist/types/run.d.ts

@@ -2,13 +2,29 @@ import { IResource, IResourceWithConfig } from "./defs";
 import { RunResult } from "./models/RunResult";
 import { RunOptions } from "./types/runner";
 /**
- * This is the central function that kicks off you runner. You can run as many resources as you want in a single process, they will run in complete isolation.
+ * This is the central function that kicks off your runner. You can run as many resources as you want in a single process, they will run in complete isolation.
  *
  * @param resourceOrResourceWithConfig - The resource or resource with config to run.
  * @param options - The options for the run.
  * @returns A promise that resolves to the result of the run.
+ *
+ * @example
+ * ```ts
+ * import { r, run } from "@bluelibs/runner";
+ *
+ * const app = r.resource("app")
+ *   .register([myTask, myService])
+ *   .build();
+ *
+ * const runtime = await run(app);
+ * await runtime.runTask(myTask, { name: "Ada" });
+ * await runtime.dispose();
+ * ```
  */
 export declare function run<C, V extends Promise<any>>(resourceOrResourceWithConfig: IResourceWithConfig<C, V> | IResource<void, V, any, any> | IResource<{
     [K in any]?: any;
 }, V, any, any>, // For optional config
 options?: RunOptions): Promise<RunResult<V extends Promise<infer U> ? U : V>>;
+export declare function __disposeActiveRunResultsForTests(): Promise<void>;
+export declare function __snapshotActiveRunResultsForTests(): ReadonlySet<RunResult<any>>;
+export declare function __disposeActiveRunResultsForTestsExcept(keep?: ReadonlySet<RunResult<any>>): Promise<void>;

package/dist/types/serializer/Serializer.d.ts

@@ -4,7 +4,7 @@
  *
  * Internal protocol reference: `readmes/SERIALIZER_PROTOCOL.md`.
  */
-import type { TypeDefinition, SerializationContext, SerializerOptions, DeserializationContext, SerializedValue, SerializedNode } from "./types";
+import type { TypeDefinition, SerializationContext, SerializerOptions } from "./types";
 export declare class Serializer {
     /** Type registry for managing custom types */
     private readonly typeRegistry;
@@ -40,45 +40,5 @@ export declare class Serializer {
      * Register a custom type for serialization/deserialization.
      */
     addType<TInstance, TSerialized>(typeDef: TypeDefinition<TInstance, TSerialized>): void;
-    addType<TJson = unknown, TInstance = unknown>(name: string, factory: (json: TJson) => TInstance): void;
-    /**
-     * @internal - Exposed for testing RegExp safety validation
-     */
-    readonly isRegExpPatternSafe: (pattern: string) => boolean;
-    /**
-     * @internal - Exposed for testing quantifier detection
-     */
-    readonly isQuantifierAt: (pattern: string, index: number) => boolean;
-    /**
-     * @internal - Exposed for testing quantifier character detection
-     */
-    readonly isQuantifierChar: (char: string, pattern: string, index: number) => boolean;
-    /**
-     * @internal - Exposed for testing bounded quantifier detection
-     */
-    readonly isBoundedQuantifier: (pattern: string, index: number) => boolean;
-    /**
-     * @internal - Exposed for test compatibility
-     */
-    toNodeRecord(nodes: Record<string, SerializedNode>): Record<string, SerializedNode>;
-    /**
-     * @internal - Exposed for test compatibility
-     */
-    deserializeValue(value: SerializedValue, context: DeserializationContext, depth?: number): unknown;
-    /**
-     * @internal - Exposed for test compatibility
-     */
-    resolveReference(id: string, context: DeserializationContext, depth?: number): unknown;
-    /**
-     * @internal - Exposed for test compatibility
-     */
-    mergePlaceholder(placeholder: unknown, result: unknown): unknown;
-    /**
-     * @internal - Exposed for test compatibility
-     */
-    isSerializedTypeRecord(value: unknown): value is {
-        __type: string;
-        value: unknown;
-    };
     private jsonStringify;
 }

package/dist/types/serializer/errors.d.ts

@@ -0,0 +1,8 @@
+import { SymbolPolicyErrorMessage } from "./types";
+export declare const invalidPayloadError: (message: string) => never;
+export declare const validationError: (message: string) => never;
+export declare const depthExceededError: (maxDepth: number) => never;
+export declare const referenceResolutionError: (message: string) => never;
+export declare const unsupportedFeatureError: (message: string) => never;
+export declare const typeRegistryError: (message: string) => never;
+export declare const symbolPolicyError: (message: SymbolPolicyErrorMessage) => never;

package/dist/types/serializer/marker-key-escapes.d.ts

@@ -0,0 +1,2 @@
+export declare const escapeReservedMarkerKey: (key: string) => string;
+export declare const unescapeReservedMarkerKey: (key: string) => string;

package/dist/types/serializer/serialize-utils.d.ts

@@ -2,7 +2,7 @@ import type { TypeDefinition } from "./types";
 import type { SerializedTypeRecord, SerializedValue } from "./types";
 import type { TypeRegistry } from "./type-registry";
 export declare const serializeArrayItems: <TSerializedValue>(source: readonly unknown[], serializeNested: (value: unknown) => TSerializedValue) => TSerializedValue[];
-export declare const serializeRecordEntries: <TSerializedValue>(source: Record<string, unknown>, unsafeKeys: ReadonlySet<string>, serializeNested: (value: unknown) => TSerializedValue) => Record<string, TSerializedValue>;
+export declare const serializeRecordEntries: <TSerializedValue>(source: Record<string, unknown>, unsafeKeys: ReadonlySet<string>, serializeNested: (value: unknown) => TSerializedValue, mapKey?: (key: string) => string) => Record<string, TSerializedValue>;
 export declare function serializeTypeRecord(typeDef: TypeDefinition<unknown, unknown>, value: unknown, excludedTypeIds: string[], serializeNested: (value: unknown) => SerializedValue): SerializedTypeRecord;
 export declare function serializeTypeRecord<TSerializedValue>(typeDef: TypeDefinition<unknown, unknown>, value: unknown, excludedTypeIds: string[], serializeNested: (value: unknown) => TSerializedValue): {
     __type: string;

package/dist/types/serializer/type-registry.d.ts

@@ -33,7 +33,6 @@ export declare class TypeRegistry {
      * Register a custom type definition.
      */
     addType<TInstance, TSerialized>(typeDef: TypeDefinition<TInstance, TSerialized>): void;
-    addType<TJson = unknown, TInstance = unknown>(name: string, factory: (json: TJson) => TInstance): void;
     /**
      * Find a type definition that matches the given value.
      */