@bluelibs/runner 5.1.0 → 5.2.1

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

@@ -0,0 +1,97 @@
+/**
+ * Global middlewares
+ */
+export declare const globalMiddlewares: {
+    requireContext: import("..").ITaskMiddleware<import("./types").RequireContextMiddlewareConfig, void, void, any>;
+    task: {
+        requireContext: import("..").ITaskMiddleware<import("./types").RequireContextMiddlewareConfig, void, void, any>;
+        cache: import("..").ITaskMiddleware<any, void, void, {
+            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;
+            }>, {
+                cacheFactoryTask: import("..").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("..").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+            }, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }> & {
+            journalKeys: {
+                readonly hit: import("..").JournalKey<boolean>;
+            };
+        };
+        concurrency: import("..").ITaskMiddleware<import("./types").ConcurrencyMiddlewareConfig, void, void, {
+            state: import("..").IResource<void, Promise<{
+                semaphoresByConfig: WeakMap<import("./types").ConcurrencyMiddlewareConfig, import("..").Semaphore>;
+                semaphoresByKey: Map<string, {
+                    semaphore: import("..").Semaphore;
+                    limit: number;
+                }>;
+            }>, {}, any, any, import("..").ITag<{
+                metadata?: Record<string, any>;
+            }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }>;
+        debounce: import("..").ITaskMiddleware<import("./types").TemporalMiddlewareConfig, void, void, {
+            state: import("..").IResource<void, Promise<{
+                debounceStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").DebounceState>;
+                throttleStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").ThrottleState>;
+            }>, {}, any, any, import("..").ITag<{
+                metadata?: Record<string, any>;
+            }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }>;
+        throttle: import("..").ITaskMiddleware<import("./types").TemporalMiddlewareConfig, void, void, {
+            state: import("..").IResource<void, Promise<{
+                debounceStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").DebounceState>;
+                throttleStates: WeakMap<import("./types").TemporalMiddlewareConfig, import("./types").ThrottleState>;
+            }>, {}, any, any, import("..").ITag<{
+                metadata?: Record<string, any>;
+            }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }>;
+        fallback: import("..").ITaskMiddleware<import("./types").FallbackMiddlewareConfig, void, void, {
+            taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }> & {
+            journalKeys: {
+                readonly active: import("..").JournalKey<boolean>;
+                readonly error: import("..").JournalKey<Error>;
+            };
+        };
+        rateLimit: import("..").ITaskMiddleware<import("./types").RateLimitMiddlewareConfig, void, void, {
+            state: import("..").IResource<void, Promise<{
+                states: WeakMap<import("./types").RateLimitMiddlewareConfig, import("./types").RateLimitState>;
+            }>, {}, any, any, import("..").ITag<{
+                metadata?: Record<string, any>;
+            }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }> & {
+            journalKeys: {
+                readonly remaining: import("..").JournalKey<number>;
+                readonly resetTime: import("..").JournalKey<number>;
+                readonly limit: import("..").JournalKey<number>;
+            };
+        };
+        retry: import("..").ITaskMiddleware<import("./types").RetryMiddlewareConfig, void, void, any> & {
+            journalKeys: {
+                readonly attempt: import("..").JournalKey<number>;
+                readonly lastError: import("..").JournalKey<Error>;
+            };
+        };
+        timeout: import("..").ITaskMiddleware<import("./types").TimeoutMiddlewareConfig, void, void, any> & {
+            journalKeys: {
+                readonly abortController: import("..").JournalKey<AbortController>;
+            };
+        };
+        circuitBreaker: import("..").ITaskMiddleware<import("./types").CircuitBreakerMiddlewareConfig, void, void, {
+            state: import("..").IResource<void, Promise<{
+                statusMap: Map<string, import("./types").CircuitBreakerStatus>;
+            }>, {}, any, any, import("..").ITag<{
+                metadata?: Record<string, any>;
+            }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+        }> & {
+            journalKeys: {
+                readonly state: import("..").JournalKey<import("./types").CircuitBreakerState>;
+                readonly failures: import("..").JournalKey<number>;
+            };
+        };
+    };
+    resource: {
+        retry: import("..").IResourceMiddleware<import("./types").RetryMiddlewareConfig, void, void, any>;
+        timeout: import("..").IResourceMiddleware<import("./types").TimeoutMiddlewareConfig, void, void, any>;
+    };
+};

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

@@ -0,0 +1,64 @@
+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[]>;
+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 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;
+    }>, {
+        cacheFactoryTask: import("..").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("..").ICacheInstance>, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>;
+    }, 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>;
+    }>, {}, {
+        map: Map<string, import("..").Queue>;
+    }, {
+        title: string;
+        description: string;
+    }, 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[]>;
+    }, any, {
+        title: string;
+        description: string;
+    }, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly rateLimit: import("..").IResource<void, Promise<{
+        states: WeakMap<import("./types").RateLimitMiddlewareConfig, import("./types").RateLimitState>;
+    }>, {}, any, any, import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly circuitBreaker: import("..").IResource<void, Promise<{
+        statusMap: Map<string, import("./types").CircuitBreakerStatus>;
+    }>, {}, 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<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+    readonly concurrency: import("..").IResource<void, Promise<{
+        semaphoresByConfig: WeakMap<import("./types").ConcurrencyMiddlewareConfig, import("..").Semaphore>;
+        semaphoresByKey: Map<string, {
+            semaphore: import("..").Semaphore;
+            limit: number;
+        }>;
+    }>, {}, any, any, import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
+};

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

@@ -0,0 +1,12 @@
+export declare const globalTags: {
+    system: import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>;
+    excludeFromGlobalHooks: import("..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>;
+    debug: import("..").ITag<import("./types").DebugFriendlyConfig, void, void>;
+    tunnel: import("..").ITag<void, void, import("./types").TunnelRunner>;
+    tunnelPolicy: import("..").ITag<import("./types").TunnelTaskMiddlewarePolicyConfig, void, void>;
+    authValidator: import("..").ITag<void, void, void>;
+};

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

@@ -0,0 +1,36 @@
+import { LRUCache } from "lru-cache";
+export interface ICacheInstance {
+    set(key: string, value: any): void;
+    get(key: string): any;
+    clear(): void;
+    /** Optional presence check to disambiguate cached undefined values */
+    has?(key: string): boolean;
+}
+export declare const cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+export interface CacheResourceConfig {
+    defaultOptions?: any;
+}
+/**
+ * Journal keys exposed by the cache middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** Whether the result was served from cache (true) or freshly computed (false) */
+    readonly hit: import("../..").JournalKey<boolean>;
+};
+export declare const cacheResource: import("../..").IResource<CacheResourceConfig, Promise<{
+    map: Map<string, ICacheInstance>;
+    cacheFactoryTask: import("../..").TaskDependencyWithIntercept<LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
+    defaultOptions: any;
+}>, {
+    cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const cacheMiddleware: import("../..").ITaskMiddleware<any, void, void, {
+    cache: import("../..").IResource<CacheResourceConfig, Promise<{
+        map: Map<string, ICacheInstance>;
+        cacheFactoryTask: import("../..").TaskDependencyWithIntercept<LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
+        defaultOptions: any;
+    }>, {
+        cacheFactoryTask: import("../..").ITask<LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, import("../..").TagType[], import("../..").TaskMiddlewareAttachmentType[]>;
+    }, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,56 @@
+/**
+ * States of the Circuit Breaker
+ */
+export declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+/**
+ * Configuration for the Circuit Breaker middleware
+ */
+export interface CircuitBreakerMiddlewareConfig {
+    /**
+     * Number of failures before tripping the circuit
+     * @default 5
+     */
+    failureThreshold?: number;
+    /**
+     * Time in milliseconds before transitioning from OPEN to HALF_OPEN
+     * @default 30000 (30 seconds)
+     */
+    resetTimeout?: number;
+}
+/**
+ * Error thrown when the circuit is OPEN
+ */
+export declare class CircuitBreakerOpenError extends Error {
+    constructor(message: string);
+}
+export interface CircuitBreakerStatus {
+    state: CircuitBreakerState;
+    failures: number;
+    lastFailureTime: number;
+}
+/**
+ * Journal keys exposed by the circuit breaker middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** Current state of the circuit breaker (CLOSED, OPEN, or HALF_OPEN) */
+    readonly state: import("../..").JournalKey<CircuitBreakerState>;
+    /** Current failure count */
+    readonly failures: import("../..").JournalKey<number>;
+};
+export declare const circuitBreakerResource: import("../..").IResource<void, Promise<{
+    statusMap: Map<string, CircuitBreakerStatus>;
+}>, {}, any, any, import("../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const circuitBreakerMiddleware: import("../..").ITaskMiddleware<CircuitBreakerMiddlewareConfig, void, void, {
+    state: import("../..").IResource<void, Promise<{
+        statusMap: Map<string, CircuitBreakerStatus>;
+    }>, {}, any, any, import("../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,47 @@
+import { Semaphore } from "../../models/Semaphore";
+export interface ConcurrencyMiddlewareConfig {
+    /**
+     * Maximum number of concurrent executions.
+     * If provided, a Semaphore will be created and shared for this config object.
+     */
+    limit?: number;
+    /**
+     * Optional key to identify a shared semaphore.
+     * If provided, the semaphore will be shared across all tasks using the same key.
+     */
+    key?: string;
+    /**
+     * An existing Semaphore instance to use.
+     */
+    semaphore?: Semaphore;
+}
+export interface ConcurrencyState {
+    semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
+    semaphoresByKey: Map<string, {
+        semaphore: Semaphore;
+        limit: number;
+    }>;
+}
+export declare const concurrencyResource: import("../..").IResource<void, Promise<{
+    semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
+    semaphoresByKey: Map<string, {
+        semaphore: Semaphore;
+        limit: number;
+    }>;
+}>, {}, any, any, import("../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+/**
+ * Middleware that limits concurrency of task executions using a Semaphore.
+ */
+export declare const concurrencyTaskMiddleware: import("../..").ITaskMiddleware<ConcurrencyMiddlewareConfig, void, void, {
+    state: import("../..").IResource<void, Promise<{
+        semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
+        semaphoresByKey: Map<string, {
+            semaphore: Semaphore;
+            limit: number;
+        }>;
+    }>, {}, any, any, import("../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,23 @@
+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;
+}
+/**
+ * Journal keys exposed by the fallback middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** Whether the fallback path was taken (true) or primary succeeded (false) */
+    readonly active: import("../..").JournalKey<boolean>;
+    /** The error that triggered the fallback (only set when active is true) */
+    readonly error: import("../..").JournalKey<Error>;
+};
+/**
+ * Fallback middleware: provides a backup value or execution if the main task fails.
+ */
+export declare const fallbackTaskMiddleware: import("../..").ITaskMiddleware<FallbackMiddlewareConfig, void, void, {
+    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,47 @@
+export interface RateLimitMiddlewareConfig {
+    /**
+     * Time window in milliseconds
+     */
+    windowMs: number;
+    /**
+     * Maximum number of requests within the window
+     */
+    max: number;
+}
+/**
+ * Custom error class for rate limit errors.
+ */
+export declare class RateLimitError extends Error {
+    constructor(message: string);
+}
+export interface RateLimitState {
+    count: number;
+    resetTime: number;
+}
+/**
+ * Journal keys exposed by the rate limit middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** Number of remaining requests in the current window */
+    readonly remaining: import("../..").JournalKey<number>;
+    /** Timestamp when the current window resets */
+    readonly resetTime: import("../..").JournalKey<number>;
+    /** Maximum requests allowed per window */
+    readonly limit: import("../..").JournalKey<number>;
+};
+export declare const rateLimitResource: import("../..").IResource<void, Promise<{
+    states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+}>, {}, any, any, import("../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+/**
+ * Rate limit middleware: limits the number of executions within a fixed time window.
+ */
+export declare const rateLimitTaskMiddleware: import("../..").ITaskMiddleware<RateLimitMiddlewareConfig, void, void, {
+    state: import("../..").IResource<void, Promise<{
+        states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+    }>, {}, any, any, import("../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,5 @@
+import type { IAsyncContext } from "../../definers/defineAsyncContext";
+export interface RequireContextMiddlewareConfig {
+    context: IAsyncContext<any>;
+}
+export declare const requireContextTaskMiddleware: import("../..").ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;

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

@@ -0,0 +1,31 @@
+/**
+ * Configuration options for the retry middleware
+ */
+export interface RetryMiddlewareConfig {
+    /**
+     * Maximum number of retry attempts (default: 3)
+     */
+    retries?: number;
+    /**
+     * Callback to determine if retry should stop based on error
+     * @default () => false (retry all errors)
+     */
+    stopRetryIf?: (error: Error) => boolean;
+    /**
+     * Custom delay strategy function
+     * @default Exponential backoff starting at 100ms
+     */
+    delayStrategy?: (attempt: number, error: Error) => number;
+}
+/**
+ * Journal keys exposed by the retry middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** Current retry attempt number (0 = first attempt, 1 = first retry, etc.) */
+    readonly attempt: import("../..").JournalKey<number>;
+    /** The last error that caused a retry */
+    readonly lastError: import("../..").JournalKey<Error>;
+};
+export declare const retryTaskMiddleware: import("../..").ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
+export declare const retryResourceMiddleware: import("../..").IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;

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

@@ -0,0 +1,48 @@
+export interface TemporalMiddlewareConfig {
+    ms: number;
+}
+export interface DebounceState {
+    timeoutId?: NodeJS.Timeout;
+    latestInput?: any;
+    resolveList: ((value: any) => void)[];
+    rejectList: ((error: any) => void)[];
+}
+export interface ThrottleState {
+    lastExecution: number;
+    timeoutId?: NodeJS.Timeout;
+    latestInput?: any;
+    resolveList: ((value: any) => void)[];
+    rejectList: ((error: any) => void)[];
+    currentPromise?: Promise<any>;
+}
+export declare const temporalResource: import("../..").IResource<void, Promise<{
+    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
+    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
+}>, {}, any, any, import("../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+/**
+ * Debounce middleware: delays execution until `ms` has passed since the last call.
+ * If multiple calls occur within the window, only the last one is executed,
+ * 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<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;
+/**
+ * Throttle middleware: ensures execution at most once every `ms`.
+ * 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<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}>;

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

@@ -0,0 +1,24 @@
+export interface TimeoutMiddlewareConfig {
+    /**
+     * Maximum time in milliseconds before the wrapped operation is aborted
+     * and a timeout error is thrown. Defaults to 5000ms.
+     */
+    ttl: number;
+}
+/**
+ * Custom error class for timeout errors.
+ * Using a class allows proper instanceof checks.
+ */
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+/**
+ * Journal keys exposed by the timeout middleware.
+ * Use these to access shared state from downstream middleware or tasks.
+ */
+export declare const journalKeys: {
+    /** The AbortController created by the timeout middleware */
+    readonly abortController: import("../..").JournalKey<AbortController>;
+};
+export declare const timeoutTaskMiddleware: import("../..").ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>;
+export declare const timeoutResourceMiddleware: import("../..").IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;

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

@@ -0,0 +1,3 @@
+import type { DependencyMapType } from "../../defs";
+import type { TunnelRunner } from "../resources/tunnel/types";
+export declare const tunnelResourceMiddleware: import("../..").IResourceMiddleware<void, DependencyMapType, TunnelRunner, DependencyMapType>;

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

@@ -0,0 +1,7 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugResource: import("../../..").IResource<DebugFriendlyConfig, Promise<any>, {}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/debug/debug.tag.d.ts

@@ -0,0 +1,2 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugTag: import("../../..").ITag<DebugFriendlyConfig, void, void>;

package/dist/types/globals/resources/debug/debugConfig.resource.d.ts

@@ -0,0 +1,22 @@
+import { DebugFriendlyConfig } from "./types";
+export declare const debugConfig: import("../../..").IResource<DebugFriendlyConfig, Promise<{
+    logResourceConfig: boolean;
+    logResourceValue: boolean;
+    logResourceBeforeRun: boolean;
+    logResourceAfterRun: boolean;
+    logTaskBeforeRun: boolean;
+    logTaskInput: boolean;
+    logTaskOutput: boolean;
+    logTaskAfterRun: boolean;
+    logMiddlewareBeforeRun: boolean;
+    logMiddlewareAfterRun: boolean;
+    logEventEmissionOnRun: boolean;
+    logEventEmissionInput: boolean;
+    logHookTriggered: boolean;
+    logHookCompleted: boolean;
+}>, {}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/debug/executionTracker.middleware.d.ts

@@ -0,0 +1,50 @@
+export declare const tasksTrackerMiddleware: import("../../..").ITaskMiddleware<any, void, void, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    store: import("../../..").IResource<void, Promise<import("../../..").Store>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}>;
+export declare const resourcesTrackerMiddleware: import("../../..").IResourceMiddleware<any, void, void, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    store: import("../../..").IResource<void, Promise<import("../../..").Store>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}>;

package/dist/types/globals/resources/debug/globalEvent.hook.d.ts

@@ -0,0 +1,27 @@
+export declare const globalEventListener: import("../../..").IHook<{
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, "*", {
+    title: string;
+    description: string;
+}>;