@bluelibs/runner 5.3.0 → 5.5.0

package/dist/types/globals/globalResources.d.ts

@@ -1,37 +1,125 @@
-import { EventManager } from "../models/EventManager";
-import { Logger } from "../models/Logger";
-import { Store } from "../models/Store";
-import { TaskRunner } from "../models/TaskRunner";
-import { MiddlewareManager } from "../models/MiddlewareManager";
-import type { SerializerLike as Serializer } from "../serializer";
-export declare const store: import("..").IResource<void, Promise<Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-export declare const serializer: import("..").IResource<void, Promise<Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+import { storeResource } from "./resources/store.resource";
+import { serializerResource as serializer } from "./resources/serializer.resource";
+import { loggerResource as logger } from "./resources/logger.resource";
+import { taskRunnerResource as taskRunner } from "./resources/taskRunner.resource";
+export { storeResource as store, serializer };
 export declare const globalResources: {
-    readonly store: import("..").IResource<void, Promise<Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly middlewareManager: import("..").IResource<void, Promise<MiddlewareManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly eventManager: import("..").IResource<void, Promise<EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly taskRunner: import("..").IResource<void, Promise<TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly logger: import("..").IResource<void, Promise<Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly serializer: import("..").IResource<void, Promise<Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly middlewareManager: import("..").IResource<void, Promise<import("..").MiddlewareManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly eventManager: import("..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly logger: import("..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly debug: import("..").IResource<import("./types").DebugFriendlyConfig, Promise<any>, {}, any, {
+        title: string;
+        description: string;
+    }, import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly serializer: import("..").IResource<void, Promise<import("./types").Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly cache: import("..").IResource<import("./types").CacheResourceConfig, Promise<{
-        map: Map<string, import("..").ICacheInstance>;
-        cacheFactoryTask: import("..").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("..").ICacheInstance>>;
-        defaultOptions: any;
+        map: Map<string, import("./types").ICacheInstance>;
+        pendingCreates: Map<string, Promise<import("./types").ICacheInstance>>;
+        cacheFactoryTask: import("..").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("./types").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("..").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("..").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+        cacheFactoryTask: import("..").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("./types").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+    }, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly cron: import("..").IResource<void, Promise<import("./types").CronResourceValue>, import("..").DependencyMapType & {
+        store: typeof storeResource;
+        logger: typeof logger;
+        taskRunner: typeof taskRunner;
     }, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly queue: import("..").IResource<void, Promise<{
         map: Map<string, import("..").Queue>;
         run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
     }>, {}, {
+        disposed: boolean;
         map: Map<string, import("..").Queue>;
+        cleanupTimers: Map<string, NodeJS.Timeout>;
     }, {
         title: string;
         description: string;
     }, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly runtime: import("..").IResource<void, Promise<import("..").RunResult<unknown>>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly httpClientFactory: import("..").IResource<void, Promise<import("./types").HttpClientFactory>, {
-        serializer: import("..").IResource<void, Promise<Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-        store: import("..").IResource<void, Promise<Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+        serializer: import("..").IResource<void, Promise<import("./types").Serializer>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+        store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     }, any, {
         title: string;
         description: string;
@@ -46,10 +134,7 @@ export declare const globalResources: {
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly temporal: import("..").IResource<void, Promise<{
-        debounceStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").DebounceState>;
-        throttleStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").ThrottleState>;
-    }>, {}, any, any, import("..").ITag<{
+    readonly temporal: import("..").IResource<void, Promise<import("./middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly concurrency: import("..").IResource<void, Promise<{
@@ -58,6 +143,7 @@ export declare const globalResources: {
             semaphore: import("..").Semaphore;
             limit: number;
         }>;
+        semaphores: Set<import("..").Semaphore>;
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/globalTags.d.ts

@@ -1,4 +1,5 @@
-export declare const globalTags: {
+import { tunnelTaskPolicyTag } from "./resources/tunnel/tunnel.policy.tag";
+declare const globalTagsBase: {
     system: import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>;
@@ -6,7 +7,14 @@ export declare const globalTags: {
         metadata?: Record<string, any>;
     }, void, void>;
     debug: import("..").ITag<import("./types").DebugFriendlyConfig, void, void>;
+    cron: import("..").ITag<import("./types").CronTagConfig, void, void>;
     tunnel: import("..").ITag<void, void, import("./types").TunnelRunner>;
-    tunnelPolicy: import("..").ITag<import("./types").TunnelTaskMiddlewarePolicyConfig, void, void>;
+    tunnelTaskPolicy: import("..").ITag<import("./types").TunnelTaskMiddlewarePolicyConfig, void, void>;
     authValidator: import("..").ITag<void, void, void>;
 };
+type GlobalTags = typeof globalTagsBase & {
+    /** @deprecated Use globals.tags.tunnelTaskPolicy instead. */
+    tunnelPolicy: typeof tunnelTaskPolicyTag;
+};
+export declare const globalTags: GlobalTags;
+export {};

package/dist/types/globals/middleware/cache.middleware.d.ts

@@ -1,15 +1,20 @@
 import { LRUCache } from "lru-cache";
 export interface ICacheInstance {
-    set(key: string, value: any): void;
-    get(key: string): any;
-    clear(): void;
+    set(key: string, value: unknown): unknown | Promise<unknown>;
+    get(key: string): unknown | Promise<unknown>;
+    clear(): void | Promise<void>;
     /** Optional presence check to disambiguate cached undefined values */
-    has?(key: string): boolean;
+    has?(key: string): boolean | Promise<boolean>;
 }
-export declare const cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+type CacheStoredValue = NonNullable<unknown>;
+type CacheFactoryOptions = Partial<LRUCache.Options<string, CacheStoredValue, unknown>>;
+export declare const cacheFactoryTask: import("../..").ITask<CacheFactoryOptions, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
 export interface CacheResourceConfig {
-    defaultOptions?: any;
+    defaultOptions?: CacheFactoryOptions;
 }
+type CacheMiddlewareConfig = CacheFactoryOptions & {
+    keyBuilder?: (taskId: string, input: unknown) => string;
+};
 /**
  * Journal keys exposed by the cache middleware.
  * Use these to access shared state from downstream middleware or tasks.
@@ -20,17 +25,172 @@ export declare const journalKeys: {
 };
 export declare const cacheResource: import("../..").IResource<CacheResourceConfig, Promise<{
     map: Map<string, ICacheInstance>;
-    cacheFactoryTask: import("../..").TaskDependencyWithIntercept<LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
-    defaultOptions: any;
+    pendingCreates: Map<string, Promise<ICacheInstance>>;
+    cacheFactoryTask: import("../..").TaskDependencyWithIntercept<CacheFactoryOptions, Promise<ICacheInstance>>;
+    defaultOptions: {
+        ttl: number;
+        max: number;
+        ttlAutopurge: boolean;
+    } | {
+        max: LRUCache.Count;
+        ttl: LRUCache.Milliseconds;
+        ttlResolution?: LRUCache.Milliseconds | undefined;
+        ttlAutopurge: boolean;
+        updateAgeOnGet?: boolean | undefined;
+        updateAgeOnHas?: boolean | undefined;
+        allowStale?: boolean | undefined;
+        dispose?: LRUCache.Disposer<string, {}> | undefined;
+        onInsert?: LRUCache.Inserter<string, {}> | undefined;
+        disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+        noDisposeOnSet?: boolean | undefined;
+        noUpdateTTL?: boolean | undefined;
+        maxSize?: LRUCache.Size | undefined;
+        maxEntrySize?: LRUCache.Size | undefined;
+        sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+        fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+        memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+        noDeleteOnFetchRejection?: boolean | undefined;
+        noDeleteOnStaleGet?: boolean | undefined;
+        allowStaleOnFetchRejection?: boolean | undefined;
+        allowStaleOnFetchAbort?: boolean | undefined;
+        ignoreFetchAbort?: boolean | undefined;
+        perf?: import("lru-cache").Perf | undefined;
+    } | {
+        maxSize?: number | undefined;
+        max: LRUCache.Count;
+        ttl: LRUCache.Milliseconds;
+        ttlResolution?: LRUCache.Milliseconds | undefined;
+        ttlAutopurge: boolean;
+        updateAgeOnGet?: boolean | undefined;
+        updateAgeOnHas?: boolean | undefined;
+        allowStale?: boolean | undefined;
+        dispose?: LRUCache.Disposer<string, {}> | undefined;
+        onInsert?: LRUCache.Inserter<string, {}> | undefined;
+        disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+        noDisposeOnSet?: boolean | undefined;
+        noUpdateTTL?: boolean | undefined;
+        maxEntrySize?: LRUCache.Size | undefined;
+        sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+        fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+        memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+        noDeleteOnFetchRejection?: boolean | undefined;
+        noDeleteOnStaleGet?: boolean | undefined;
+        allowStaleOnFetchRejection?: boolean | undefined;
+        allowStaleOnFetchAbort?: boolean | undefined;
+        ignoreFetchAbort?: boolean | undefined;
+        perf?: import("lru-cache").Perf | undefined;
+    } | {
+        ttl: LRUCache.Milliseconds;
+        ttlAutopurge: boolean;
+        max: LRUCache.Count;
+        ttlResolution?: LRUCache.Milliseconds | undefined;
+        updateAgeOnGet?: boolean | undefined;
+        updateAgeOnHas?: boolean | undefined;
+        allowStale?: boolean | undefined;
+        dispose?: LRUCache.Disposer<string, {}> | undefined;
+        onInsert?: LRUCache.Inserter<string, {}> | undefined;
+        disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+        noDisposeOnSet?: boolean | undefined;
+        noUpdateTTL?: boolean | undefined;
+        maxSize?: LRUCache.Size | undefined;
+        maxEntrySize?: LRUCache.Size | undefined;
+        sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+        fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+        memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+        noDeleteOnFetchRejection?: boolean | undefined;
+        noDeleteOnStaleGet?: boolean | undefined;
+        allowStaleOnFetchRejection?: boolean | undefined;
+        allowStaleOnFetchAbort?: boolean | undefined;
+        ignoreFetchAbort?: boolean | undefined;
+        perf?: import("lru-cache").Perf | undefined;
+    };
 }>, {
-    cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+    cacheFactoryTask: import("../..").ITask<CacheFactoryOptions, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
 }, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-export declare const cacheMiddleware: import("../..").ITaskMiddleware<any, void, void, {
+export declare const cacheMiddleware: import("../..").ITaskMiddleware<CacheMiddlewareConfig, void, void, {
     cache: import("../..").IResource<CacheResourceConfig, Promise<{
         map: Map<string, ICacheInstance>;
-        cacheFactoryTask: import("../..").TaskDependencyWithIntercept<LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
-        defaultOptions: any;
+        pendingCreates: Map<string, Promise<ICacheInstance>>;
+        cacheFactoryTask: import("../..").TaskDependencyWithIntercept<CacheFactoryOptions, Promise<ICacheInstance>>;
+        defaultOptions: {
+            ttl: number;
+            max: number;
+            ttlAutopurge: boolean;
+        } | {
+            max: LRUCache.Count;
+            ttl: LRUCache.Milliseconds;
+            ttlResolution?: LRUCache.Milliseconds | undefined;
+            ttlAutopurge: boolean;
+            updateAgeOnGet?: boolean | undefined;
+            updateAgeOnHas?: boolean | undefined;
+            allowStale?: boolean | undefined;
+            dispose?: LRUCache.Disposer<string, {}> | undefined;
+            onInsert?: LRUCache.Inserter<string, {}> | undefined;
+            disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+            noDisposeOnSet?: boolean | undefined;
+            noUpdateTTL?: boolean | undefined;
+            maxSize?: LRUCache.Size | undefined;
+            maxEntrySize?: LRUCache.Size | undefined;
+            sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+            fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+            memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+            noDeleteOnFetchRejection?: boolean | undefined;
+            noDeleteOnStaleGet?: boolean | undefined;
+            allowStaleOnFetchRejection?: boolean | undefined;
+            allowStaleOnFetchAbort?: boolean | undefined;
+            ignoreFetchAbort?: boolean | undefined;
+            perf?: import("lru-cache").Perf | undefined;
+        } | {
+            maxSize?: number | undefined;
+            max: LRUCache.Count;
+            ttl: LRUCache.Milliseconds;
+            ttlResolution?: LRUCache.Milliseconds | undefined;
+            ttlAutopurge: boolean;
+            updateAgeOnGet?: boolean | undefined;
+            updateAgeOnHas?: boolean | undefined;
+            allowStale?: boolean | undefined;
+            dispose?: LRUCache.Disposer<string, {}> | undefined;
+            onInsert?: LRUCache.Inserter<string, {}> | undefined;
+            disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+            noDisposeOnSet?: boolean | undefined;
+            noUpdateTTL?: boolean | undefined;
+            maxEntrySize?: LRUCache.Size | undefined;
+            sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+            fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+            memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+            noDeleteOnFetchRejection?: boolean | undefined;
+            noDeleteOnStaleGet?: boolean | undefined;
+            allowStaleOnFetchRejection?: boolean | undefined;
+            allowStaleOnFetchAbort?: boolean | undefined;
+            ignoreFetchAbort?: boolean | undefined;
+            perf?: import("lru-cache").Perf | undefined;
+        } | {
+            ttl: LRUCache.Milliseconds;
+            ttlAutopurge: boolean;
+            max: LRUCache.Count;
+            ttlResolution?: LRUCache.Milliseconds | undefined;
+            updateAgeOnGet?: boolean | undefined;
+            updateAgeOnHas?: boolean | undefined;
+            allowStale?: boolean | undefined;
+            dispose?: LRUCache.Disposer<string, {}> | undefined;
+            onInsert?: LRUCache.Inserter<string, {}> | undefined;
+            disposeAfter?: LRUCache.Disposer<string, {}> | undefined;
+            noDisposeOnSet?: boolean | undefined;
+            noUpdateTTL?: boolean | undefined;
+            maxSize?: LRUCache.Size | undefined;
+            maxEntrySize?: LRUCache.Size | undefined;
+            sizeCalculation?: LRUCache.SizeCalculator<string, {}> | undefined;
+            fetchMethod?: LRUCache.Fetcher<string, {}, unknown> | undefined;
+            memoMethod?: LRUCache.Memoizer<string, {}, unknown> | undefined;
+            noDeleteOnFetchRejection?: boolean | undefined;
+            noDeleteOnStaleGet?: boolean | undefined;
+            allowStaleOnFetchRejection?: boolean | undefined;
+            allowStaleOnFetchAbort?: boolean | undefined;
+            ignoreFetchAbort?: boolean | undefined;
+            perf?: import("lru-cache").Perf | undefined;
+        };
     }>, {
-        cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+        cacheFactoryTask: import("../..").ITask<CacheFactoryOptions, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
     }, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
+export {};

package/dist/types/globals/middleware/circuitBreaker.middleware.d.ts

@@ -1,3 +1,4 @@
+import { RunnerError } from "../../definers/defineError";
 /**
  * States of the Circuit Breaker
  */
@@ -24,13 +25,16 @@ export interface CircuitBreakerMiddlewareConfig {
 /**
  * Error thrown when the circuit is OPEN
  */
-export declare class CircuitBreakerOpenError extends Error {
+export declare class CircuitBreakerOpenError extends RunnerError<{
+    message: string;
+}> {
     constructor(message: string);
 }
 export interface CircuitBreakerStatus {
     state: CircuitBreakerState;
     failures: number;
     lastFailureTime: number;
+    halfOpenProbeInFlight: boolean;
 }
 /**
  * Journal keys exposed by the circuit breaker middleware.

package/dist/types/globals/middleware/concurrency.middleware.d.ts

@@ -21,6 +21,7 @@ export interface ConcurrencyState {
         semaphore: Semaphore;
         limit: number;
     }>;
+    semaphores: Set<Semaphore>;
 }
 export declare const concurrencyResource: import("../..").IResource<void, Promise<{
     semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
@@ -28,6 +29,7 @@ export declare const concurrencyResource: import("../..").IResource<void, Promis
         semaphore: Semaphore;
         limit: number;
     }>;
+    semaphores: Set<Semaphore>;
 }>, {}, any, any, import("../..").ITag<{
     metadata?: Record<string, any>;
 }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
@@ -41,6 +43,7 @@ export declare const concurrencyTaskMiddleware: import("../..").ITaskMiddleware<
             semaphore: Semaphore;
             limit: number;
         }>;
+        semaphores: Set<Semaphore>;
     }>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/middleware/fallback.middleware.d.ts

@@ -1,9 +1,15 @@
+import type { ITask } from "../../defs";
+type FallbackTask = ITask;
+type FallbackResolver = {
+    bivarianceHack(error: unknown, input: unknown): unknown | Promise<unknown>;
+}["bivarianceHack"];
+type FallbackValue = string | number | boolean | bigint | symbol | null | undefined | Record<string, unknown> | Array<unknown>;
 export interface FallbackMiddlewareConfig {
     /**
      * The fallback to use if the task fails.
      * Can be a value, a function that returns a value (or promise), or another task.
      */
-    fallback: any;
+    fallback: FallbackTask | FallbackResolver | FallbackValue;
 }
 /**
  * Journal keys exposed by the fallback middleware.
@@ -21,3 +27,4 @@ export declare const journalKeys: {
 export declare const fallbackTaskMiddleware: import("../..").ITaskMiddleware<FallbackMiddlewareConfig, void, void, {
     taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
+export {};

package/dist/types/globals/middleware/rateLimit.middleware.d.ts

@@ -1,3 +1,4 @@
+import { RunnerError } from "../../definers/defineError";
 export interface RateLimitMiddlewareConfig {
     /**
      * Time window in milliseconds
@@ -11,7 +12,9 @@ export interface RateLimitMiddlewareConfig {
 /**
  * Custom error class for rate limit errors.
  */
-export declare class RateLimitError extends Error {
+export declare class RateLimitError extends RunnerError<{
+    message: string;
+}> {
     constructor(message: string);
 }
 export interface RateLimitState {

package/dist/types/globals/middleware/retry.middleware.d.ts

@@ -29,3 +29,8 @@ export declare const journalKeys: {
 };
 export declare const retryTaskMiddleware: import("../..").ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
 export declare const retryResourceMiddleware: import("../..").IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
+/**
+ * Delay that can be cancelled via an AbortSignal so retries don't block disposal.
+ * @internal Exported for testing only.
+ */
+export declare function abortableDelay(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/types/globals/middleware/temporal.middleware.d.ts

@@ -1,24 +1,29 @@
 export interface TemporalMiddlewareConfig {
     ms: number;
 }
+type TimeoutHandle = ReturnType<typeof setTimeout>;
 export interface DebounceState {
-    timeoutId?: NodeJS.Timeout;
-    latestInput?: any;
-    resolveList: ((value: any) => void)[];
-    rejectList: ((error: any) => void)[];
+    timeoutId?: TimeoutHandle;
+    latestInput?: unknown;
+    resolveList: ((value: unknown) => void)[];
+    rejectList: ((error: unknown) => void)[];
 }
 export interface ThrottleState {
     lastExecution: number;
-    timeoutId?: NodeJS.Timeout;
-    latestInput?: any;
-    resolveList: ((value: any) => void)[];
-    rejectList: ((error: any) => void)[];
-    currentPromise?: Promise<any>;
+    timeoutId?: TimeoutHandle;
+    latestInput?: unknown;
+    resolveList: ((value: unknown) => void)[];
+    rejectList: ((error: unknown) => void)[];
+    currentPromise?: Promise<unknown>;
 }
-export declare const temporalResource: import("../..").IResource<void, Promise<{
+export interface TemporalResourceState {
     debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
     throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
-}>, {}, any, any, import("../..").ITag<{
+    trackedDebounceStates: Set<DebounceState>;
+    trackedThrottleStates: Set<ThrottleState>;
+    isDisposed: boolean;
+}
+export declare const temporalResource: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
     metadata?: Record<string, any>;
 }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
 /**
@@ -27,10 +32,7 @@ export declare const temporalResource: import("../..").IResource<void, Promise<{
  * and all callers receive the same result.
  */
 export declare const debounceTaskMiddleware: import("../..").ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
-    state: import("../..").IResource<void, Promise<{
-        debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
-        throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
-    }>, {}, any, any, import("../..").ITag<{
+    state: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
@@ -39,10 +41,8 @@ export declare const debounceTaskMiddleware: import("../..").ITaskMiddleware<Tem
  * If calls occur within the window, the last one is scheduled for the end of the window.
  */
 export declare const throttleTaskMiddleware: import("../..").ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
-    state: import("../..").IResource<void, Promise<{
-        debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
-        throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
-    }>, {}, any, any, import("../..").ITag<{
+    state: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
+export {};

package/dist/types/globals/middleware/timeout.middleware.d.ts

@@ -1,3 +1,4 @@
+import { RunnerError } from "../../definers/defineError";
 export interface TimeoutMiddlewareConfig {
     /**
      * Maximum time in milliseconds before the wrapped operation is aborted
@@ -9,7 +10,9 @@ export interface TimeoutMiddlewareConfig {
  * Custom error class for timeout errors.
  * Using a class allows proper instanceof checks.
  */
-export declare class TimeoutError extends Error {
+export declare class TimeoutError extends RunnerError<{
+    message: string;
+}> {
     constructor(message: string);
 }
 /**

package/dist/types/globals/resources/eventManager.resource.d.ts

@@ -0,0 +1,2 @@
+import type { EventManager } from "../../models/EventManager";
+export declare const eventManagerResource: import("../..").IResource<void, Promise<EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/logger.resource.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "../../models/Logger";
+export declare const loggerResource: import("../..").IResource<void, Promise<Logger>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/middlewareManager.resource.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareManager } from "../../models/MiddlewareManager";
+export declare const middlewareManagerResource: import("../..").IResource<void, Promise<MiddlewareManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/queue.resource.d.ts

@@ -3,7 +3,9 @@ export declare const queueResource: import("../..").IResource<void, Promise<{
     map: Map<string, Queue>;
     run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
 }>, {}, {
+    disposed: boolean;
     map: Map<string, Queue>;
+    cleanupTimers: Map<string, NodeJS.Timeout>;
 }, {
     title: string;
     description: string;

package/dist/types/globals/resources/runtime.resource.d.ts

@@ -0,0 +1,2 @@
+import type { RunResult } from "../../models/RunResult";
+export declare const runtimeResource: import("../..").IResource<void, Promise<RunResult<unknown>>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/serializer.resource.d.ts

@@ -0,0 +1,2 @@
+import type { SerializerLike as Serializer } from "../../serializer";
+export declare const serializerResource: import("../..").IResource<void, Promise<Serializer>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/store.resource.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "../../models/Store";
+export declare const storeResource: import("../..").IResource<void, Promise<Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/taskRunner.resource.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../../models/TaskRunner";
+export declare const taskRunnerResource: import("../..").IResource<void, Promise<TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;