@bluelibs/runner 5.3.0 → 5.5.0

package/dist/types/errors/domain-runtime.errors.d.ts

@@ -0,0 +1,136 @@
+import type { DefaultErrorType } from "../types/error";
+export declare const httpBaseUrlRequiredError: import("..").IErrorHelper<{
+    clientFactory: string;
+} & DefaultErrorType>;
+export declare const httpFetchUnavailableError: import("..").IErrorHelper<{
+    clientFactory: string;
+} & DefaultErrorType>;
+export declare const httpContextSerializationError: import("..").IErrorHelper<{
+    contextId: string;
+    reason: string;
+} & DefaultErrorType>;
+export declare const httpEventWithResultUnavailableError: import("..").IErrorHelper<{
+    clientFactory: string;
+} & DefaultErrorType>;
+export declare const httpClientInputUnsupportedError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const middlewareConcurrencyConflictError: import("..").IErrorHelper<{
+    key: string;
+    existingLimit: number;
+    attemptedLimit: number;
+} & DefaultErrorType>;
+export declare const middlewareContextRequiredError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const middlewareTimeoutError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const middlewareCircuitBreakerOpenError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const middlewareRateLimitExceededError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const middlewareTemporalDisposedError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const tunnelTaskNotFoundError: import("..").IErrorHelper<{
+    taskId: string;
+} & DefaultErrorType>;
+export declare const tunnelEventNotFoundError: import("..").IErrorHelper<{
+    eventId: string;
+} & DefaultErrorType>;
+export declare const tunnelClientContractError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const resourceForkInvalidIdError: import("..").IErrorHelper<{
+    id: string;
+} & DefaultErrorType>;
+export declare const builderInvalidHttpCodeError: import("..").IErrorHelper<{
+    value: number;
+} & DefaultErrorType>;
+export declare const overrideUnsupportedBaseError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const platformUnreachableError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const platformInvariantError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const serializerInvalidPayloadError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerValidationError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerPayloadValidationError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerDepthExceededError: import("..").IErrorHelper<{
+    maxDepth: number;
+} & DefaultErrorType>;
+export declare const serializerReferenceResolutionError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerUnsupportedFeatureError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerTypeRegistryError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const serializerSymbolPolicyError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const nodeInputFileConsumedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const nodeInputFileUnavailableError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const nodeExposureMultipartLimitExceededError: import("..").IErrorHelper<{
+    message: string;
+    response?: unknown;
+} & DefaultErrorType>;
+export declare const optionalDependencyInvalidExportError: import("..").IErrorHelper<{
+    dependency: string;
+    details: string;
+} & DefaultErrorType>;
+export declare const optionalDependencyMissingError: import("..").IErrorHelper<{
+    dependency: string;
+    details: string;
+} & DefaultErrorType>;
+export declare const durableStoreShapeError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const durableQueueNotInitializedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const durableContextCancelledError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const durableStepDefinitionError: import("..").IErrorHelper<{
+    stepId: string;
+} & DefaultErrorType>;
+export declare const durableDeterminismViolationError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const durableSignalTimeoutError: import("..").IErrorHelper<{
+    signalId: string;
+} & DefaultErrorType>;
+export declare const durableScheduleConfigError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const durableExecutionError: import("..").IErrorHelper<{
+    message: string;
+    executionId: string;
+    taskId: string;
+    attempt: number;
+    causeInfo?: {
+        message: string;
+        stack?: string;
+    };
+} & DefaultErrorType>;
+export declare const durableExecutionInvariantError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const durableOperatorUnsupportedStoreCapabilityError: import("..").IErrorHelper<{
+    operation: string;
+} & DefaultErrorType>;
+export declare const dashboardApiRequestError: import("..").IErrorHelper<{
+    message: string;
+} & DefaultErrorType>;
+export declare const lockableMapLockedError: import("..").IErrorHelper<{
+    mapName: string;
+} & DefaultErrorType>;

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

@@ -0,0 +1,125 @@
+import type { DefaultErrorType } from "../types/error";
+export declare const duplicateRegistrationError: import("..").IErrorHelper<{
+    type: string;
+    id: string;
+} & DefaultErrorType>;
+export declare const dependencyNotFoundError: import("..").IErrorHelper<{
+    key: string;
+} & DefaultErrorType>;
+export declare const overrideTargetNotRegisteredError: import("..").IErrorHelper<{
+    targetId: string;
+    targetType: "Task" | "Resource" | "Task middleware" | "Resource middleware" | "Hook";
+    sources?: string[];
+} & DefaultErrorType>;
+export declare const unknownItemTypeError: import("..").IErrorHelper<{
+    item: unknown;
+} & DefaultErrorType>;
+export declare const contextError: import("..").IErrorHelper<{
+    details?: string;
+} & DefaultErrorType>;
+export declare const circularDependencyError: import("..").IErrorHelper<{
+    cycles: string[];
+} & DefaultErrorType>;
+/** @deprecated Use circularDependencyError instead. */
+export declare const circularDependenciesError: import("..").IErrorHelper<{
+    cycles: string[];
+} & DefaultErrorType>;
+/** @deprecated Use circularDependencyError instead. */
+export declare const dependencyCycleError: import("..").IErrorHelper<{
+    cycles: string[];
+} & DefaultErrorType>;
+export declare const eventNotFoundError: import("..").IErrorHelper<{
+    id: string;
+} & DefaultErrorType>;
+export declare const resourceNotFoundError: import("..").IErrorHelper<{
+    id: string;
+} & DefaultErrorType>;
+export declare const lazyResourceSyncAccessError: import("..").IErrorHelper<{
+    id: string;
+} & DefaultErrorType>;
+export declare const lazyResourceAccessDisabledError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const middlewareNotRegisteredError: import("..").IErrorHelper<{
+    type: "task" | "resource";
+    source: string;
+    middlewareId: string;
+} & DefaultErrorType>;
+export declare const tagNotFoundError: import("..").IErrorHelper<{
+    id: string;
+} & DefaultErrorType>;
+export declare const duplicateTagIdOnDefinitionError: import("..").IErrorHelper<{
+    definitionType: string;
+    definitionId: string;
+    tagId: string;
+} & DefaultErrorType>;
+export declare const lockedError: import("..").IErrorHelper<{
+    what: string;
+} & DefaultErrorType>;
+export declare const storeAlreadyInitializedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const validationError: import("..").IErrorHelper<{
+    subject: string;
+    id: string;
+    originalError: string | Error;
+} & DefaultErrorType>;
+/** Canonical error for input validation failures */
+export declare const inputSchemaValidationError: import("..").IErrorHelper<{
+    subject: string;
+    id: string;
+    originalError: string | Error;
+} & DefaultErrorType>;
+/** Canonical error for result validation failures */
+export declare const resultSchemaValidationError: import("..").IErrorHelper<{
+    subject: string;
+    id: string;
+    originalError: string | Error;
+} & DefaultErrorType>;
+export declare const eventCycleError: import("..").IErrorHelper<{
+    path: Array<{
+        id: string;
+        source: string;
+    }>;
+} & DefaultErrorType>;
+export declare const eventEmissionCycleError: import("..").IErrorHelper<{
+    cycles: string[];
+} & DefaultErrorType>;
+export declare const platformUnsupportedFunctionError: import("..").IErrorHelper<{
+    functionName: string;
+} & DefaultErrorType>;
+export declare const cancellationError: import("..").IErrorHelper<{
+    reason?: string;
+} & DefaultErrorType>;
+export declare const tunnelOwnershipConflictError: import("..").IErrorHelper<{
+    taskId: string;
+    currentOwnerId: string;
+    attemptedOwnerId: string;
+} & DefaultErrorType>;
+export declare const phantomTaskNotRoutedError: import("..").IErrorHelper<{
+    taskId: string;
+} & DefaultErrorType>;
+export declare const taskNotRegisteredError: import("..").IErrorHelper<{
+    taskId: string;
+} & DefaultErrorType>;
+export declare const visibilityViolationError: import("..").IErrorHelper<{
+    targetId: string;
+    targetType: string;
+    ownerResourceId: string;
+    consumerId: string;
+    consumerType: string;
+    exportedIds: string[];
+} & DefaultErrorType>;
+export declare const runResultDisposedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const runtimeRootNotAvailableError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const runtimeRootNotInitializedError: import("..").IErrorHelper<{
+    rootId: string;
+} & DefaultErrorType>;
+export declare const runResultDisposeDuringBootstrapError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const runtimeElementNotFoundError: import("..").IErrorHelper<{
+    type: string;
+    elementId: string;
+} & DefaultErrorType>;
+/** Builder types that require validation before build() */
+export type BuilderType = "task" | "hook" | "task-middleware" | "resource-middleware";
+export declare const builderIncompleteError: import("..").IErrorHelper<{
+    type: BuilderType;
+    builderId: string;
+    missingFields: string[];
+} & DefaultErrorType>;

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

@@ -0,0 +1 @@
+export declare const createMessageError: (message?: unknown) => never;

package/dist/types/errors/model-runtime.errors.d.ts

@@ -0,0 +1,20 @@
+import type { DefaultErrorType } from "../types/error";
+export declare const taskRunnerNotSetError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const queueDisposedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const queueDeadlockError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const semaphoreInvalidPermitsError: import("..").IErrorHelper<{
+    maxPermits: number;
+} & DefaultErrorType>;
+export declare const semaphoreNonIntegerPermitsError: import("..").IErrorHelper<{
+    maxPermits: number;
+} & DefaultErrorType>;
+export declare const semaphoreDisposedError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const semaphoreAcquireTimeoutError: import("..").IErrorHelper<{
+    timeoutMs: number;
+} & DefaultErrorType>;
+export declare const journalDuplicateKeyError: import("..").IErrorHelper<{
+    keyId: string;
+} & DefaultErrorType>;
+export declare const unknownMiddlewareTypeError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const middlewareInterceptUnknownTypeError: import("..").IErrorHelper<DefaultErrorType>;
+export declare const parallelInitSchedulingError: import("..").IErrorHelper<DefaultErrorType>;

package/dist/types/errors.d.ts

@@ -1,75 +1,6 @@
-import type { DefaultErrorType } from "./types/error";
-export declare const duplicateRegistrationError: import("./errors").IErrorHelper<{
-    type: string;
-    id: string;
-} & DefaultErrorType>;
-export declare const dependencyNotFoundError: import("./errors").IErrorHelper<{
-    key: string;
-} & DefaultErrorType>;
-export declare const unknownItemTypeError: import("./errors").IErrorHelper<{
-    item: unknown;
-} & DefaultErrorType>;
-export declare const contextError: import("./errors").IErrorHelper<{
-    details?: string;
-} & DefaultErrorType>;
-export declare const circularDependenciesError: import("./errors").IErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-export declare const eventNotFoundError: import("./errors").IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const resourceNotFoundError: import("./errors").IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const middlewareNotRegisteredError: import("./errors").IErrorHelper<{
-    type: "task" | "resource";
-    source: string;
-    middlewareId: string;
-} & DefaultErrorType>;
-export declare const tagNotFoundError: import("./errors").IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const lockedError: import("./errors").IErrorHelper<{
-    what: string;
-} & DefaultErrorType>;
-export declare const storeAlreadyInitializedError: import("./errors").IErrorHelper<DefaultErrorType>;
-export declare const validationError: import("./errors").IErrorHelper<{
-    subject: string;
-    id: string;
-    originalError: string | Error;
-} & DefaultErrorType>;
-export declare const eventCycleError: import("./errors").IErrorHelper<{
-    path: Array<{
-        id: string;
-        source: string;
-    }>;
-} & DefaultErrorType>;
-export declare const eventEmissionCycleError: import("./errors").IErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-export declare const platformUnsupportedFunctionError: import("./errors").IErrorHelper<{
-    functionName: string;
-} & DefaultErrorType>;
-export declare const cancellationError: import("./errors").IErrorHelper<{
-    reason?: string;
-} & DefaultErrorType>;
-export declare const tunnelOwnershipConflictError: import("./errors").IErrorHelper<{
-    taskId: string;
-    currentOwnerId: string;
-    attemptedOwnerId: string;
-} & DefaultErrorType>;
-export declare const phantomTaskNotRoutedError: import("./errors").IErrorHelper<{
-    taskId: string;
-} & DefaultErrorType>;
-export declare const taskNotRegisteredError: import("./errors").IErrorHelper<{
-    taskId: string;
-} & DefaultErrorType>;
-/** Builder types that require validation before build() */
-export type BuilderType = "hook" | "task-middleware" | "resource-middleware";
-export declare const builderIncompleteError: import("./errors").IErrorHelper<{
-    type: BuilderType;
-    builderId: string;
-    missingFields: string[];
-} & DefaultErrorType>;
-export declare function isCancellationError(err: unknown): boolean;
+export * from "./errors/foundation.errors";
+export * from "./errors/model-runtime.errors";
+export * from "./errors/domain-error-ids";
+export * from "./errors/domain-runtime.errors";
+export * from "./errors/generic.errors";
 export type { IErrorHelper } from "./types/error";

package/dist/types/globals/cron/cron-parser.d.ts

@@ -0,0 +1,4 @@
+export declare class CronParser {
+    static getNextRun(expression: string, from?: Date, timezone?: string): Date;
+    static isValid(expression: string, timezone?: string): boolean;
+}

package/dist/types/globals/cron/cron.errors.d.ts

@@ -0,0 +1,8 @@
+export declare const cronConfigurationError: import("../..").IErrorHelper<{
+    message: string;
+}>;
+export declare const cronExecutionError: import("../..").IErrorHelper<{
+    taskId: string;
+    expression: string;
+    message: string;
+}>;

package/dist/types/globals/cron/cron.resource.d.ts

@@ -0,0 +1,12 @@
+import type { DependencyMapType } from "../../defs";
+import { loggerResource } from "../resources/logger.resource";
+import { storeResource } from "../resources/store.resource";
+import { taskRunnerResource } from "../resources/taskRunner.resource";
+import { CronResourceValue } from "./types";
+type CronResourceDependencies = DependencyMapType & {
+    store: typeof storeResource;
+    logger: typeof loggerResource;
+    taskRunner: typeof taskRunnerResource;
+};
+export declare const cronResource: import("../..").IResource<void, Promise<CronResourceValue>, CronResourceDependencies, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export {};

package/dist/types/globals/cron/cron.tag.d.ts

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

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

@@ -0,0 +1,25 @@
+export declare enum CronOnError {
+    Continue = "continue",
+    Stop = "stop"
+}
+export interface CronTagConfig {
+    expression: string;
+    input?: unknown;
+    timezone?: string;
+    immediate?: boolean;
+    enabled?: boolean;
+    onError?: CronOnError;
+    /** When true, suppresses all cron log output for this task. Defaults to false. */
+    silent?: boolean;
+}
+export interface CronScheduledTask {
+    taskId: string;
+    expression: string;
+    timezone?: string;
+    nextRunAt?: Date;
+    enabled: boolean;
+    stopped: boolean;
+}
+export interface CronResourceValue {
+    schedules: ReadonlyMap<string, CronScheduledTask>;
+}

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

@@ -5,13 +5,92 @@ 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("..").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("..").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[]>;
         }> & {
             journalKeys: {
@@ -25,23 +104,18 @@ export declare const globalMiddlewares: {
                     semaphore: import("..").Semaphore;
                     limit: number;
                 }>;
+                semaphores: Set<import("..").Semaphore>;
             }>, {}, 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<{
+            state: import("..").IResource<void, Promise<import("./middleware/temporal.middleware").TemporalResourceState>, {}, 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<{
+            state: import("..").IResource<void, Promise<import("./middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("..").ITag<{
                 metadata?: Record<string, any>;
             }, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
         }>;