@bluelibs/runner 4.6.0 → 4.7.0-alpha

package/dist/http-client.d.ts

@@ -0,0 +1,23 @@
+import type { Readable } from "stream";
+import type { Serializer } from "./globals/resources/tunnel/serializer";
+export interface HttpClientAuth {
+    header?: string;
+    token: string;
+}
+export interface HttpClientConfig {
+    baseUrl: string;
+    auth?: HttpClientAuth;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: Serializer;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export interface HttpClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable | ReadableStream<Uint8Array>>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+}
+export declare function createHttpClient(cfg: HttpClientConfig): HttpClient;
+export type { Readable };

package/dist/http-fetch-tunnel.resource.d.ts

@@ -0,0 +1,22 @@
+import { Serializer } from "./globals/resources/tunnel/serializer";
+export { normalizeError } from "./globals/resources/tunnel/error-utils";
+export interface ExposureFetchAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface ExposureFetchConfig {
+    baseUrl: string;
+    auth?: ExposureFetchAuthConfig;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: Serializer;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export interface ExposureFetchClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+}
+export declare function createExposureFetch(cfg: ExposureFetchConfig): ExposureFetchClient;

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import { defineTask, defineResource, defineEvent, defineTaskMiddleware, defineResourceMiddleware, defineTag, defineOverride, defineHook } from "./define";
+import { createContext } from "./context";
+import { run } from "./run";
+import { createTestResource } from "./testing";
+declare const globals: {
+    events: {
+        readonly ready: import(".").IEvent<void>;
+    };
+    resources: {
+        store: import(".").IResource<void, Promise<import("./models").Store>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        middlewareManager: import(".").IResource<void, Promise<import("./models").MiddlewareManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        eventManager: import(".").IResource<void, Promise<import("./models").EventManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        taskRunner: import(".").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        logger: import(".").IResource<void, Promise<import("./models").Logger>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        serializer: import(".").IResource<void, Promise<import("./globals/resources/tunnel/serializer").Serializer>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        cache: import(".").IResource<{
+            defaultOptions?: any;
+        }, Promise<{
+            map: Map<string, import(".").ICacheInstance>;
+            cacheFactoryTask: import(".").TaskDependencyWithIntercept<any, Promise<import(".").ICacheInstance>>;
+            defaultOptions: any;
+        }>, {
+            cacheFactoryTask: import(".").ITask<any, Promise<import(".").ICacheInstance>, any, any, import(".").TagType[], import(".").TaskMiddlewareAttachmentType[]>;
+        }, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+        queue: import(".").IResource<void, Promise<{
+            map: Map<string, import("./models").Queue>;
+            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+        }>, {}, {
+            map: Map<string, import("./models").Queue>;
+        }, {
+            title: string;
+            description: string;
+        }, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+    };
+    middleware: {
+        requireContext: import(".").ITaskMiddleware<{
+            context: import("./context").Context<any>;
+        }, void, void, any>;
+        task: {
+            requireContext: import(".").ITaskMiddleware<{
+                context: import("./context").Context<any>;
+            }, void, void, any>;
+            cache: import(".").ITaskMiddleware<any, void, void, {
+                cache: import(".").IResource<{
+                    defaultOptions?: any;
+                }, Promise<{
+                    map: Map<string, import(".").ICacheInstance>;
+                    cacheFactoryTask: import(".").TaskDependencyWithIntercept<any, Promise<import(".").ICacheInstance>>;
+                    defaultOptions: any;
+                }>, {
+                    cacheFactoryTask: import(".").ITask<any, Promise<import(".").ICacheInstance>, any, any, import(".").TagType[], import(".").TaskMiddlewareAttachmentType[]>;
+                }, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
+            }>;
+            retry: import(".").ITaskMiddleware<import("./globals/middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
+            timeout: import(".").ITaskMiddleware<import("./globals/middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
+        };
+        resource: {
+            retry: import(".").IResourceMiddleware<import("./globals/middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
+            timeout: import(".").IResourceMiddleware<import("./globals/middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
+        };
+    };
+    tags: {
+        system: import(".").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>;
+        excludeFromGlobalHooks: import(".").ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>;
+        debug: import(".").ITag<import(".").DebugFriendlyConfig, void, void>;
+        tunnel: import(".").ITag<void, void, import("./globals/resources/tunnel/types").TunnelRunner>;
+        tunnelPolicy: import(".").ITag<import("./globals/resources/tunnel/tunnel.policy.tag").TunnelTaskMiddlewarePolicyConfig, void, void>;
+    };
+    tunnels: Readonly<{
+        http: Readonly<{
+            createClient(cfg: import("./globals/tunnels").HttpCreateClientConfig): import("./http-fetch-tunnel.resource").ExposureFetchClient;
+        }>;
+    }>;
+};
+export { globals };
+export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineTag as tag, defineOverride as override, defineHook as hook, run, createContext, createTestResource, };
+export declare const r: Readonly<{
+    resource: typeof import("./definers/builders/resource").resourceBuilder;
+    task: import("./definers/builders/task").TaskBuilderWithPhantom;
+    event: typeof import("./definers/builders/event").eventBuilder;
+    hook: typeof import("./definers/builders/hook").hookBuilder;
+    tag: typeof import("./definers/builders/tag").tagBuilder;
+    middleware: Readonly<{
+        task: typeof import("./definers/builders/middleware").taskMiddlewareBuilder;
+        resource: typeof import("./definers/builders/middleware").resourceMiddlewareBuilder;
+    }>;
+}>;
+export * as definitions from "./defs";
+export * from "./models";
+export * from "./globals/types";
+export * as Errors from "./errors";
+export { Context } from "./context";
+export { PlatformAdapter, setPlatform } from "./platform";
+export { EJSON } from "@bluelibs/ejson";
+export type * from "./defs";

package/dist/models/DependencyProcessor.d.ts

@@ -0,0 +1,48 @@
+import { DependencyMapType, DependencyValuesType, ITask, IResource, IEvent } from "../defs";
+import { Store } from "./Store";
+import { ResourceStoreElementType } from "../types/storeTypes";
+import { EventManager } from "./EventManager";
+import { ResourceInitializer } from "./ResourceInitializer";
+import { TaskRunner } from "./TaskRunner";
+import { Logger } from "./Logger";
+/**
+ * This class is responsible of setting up dependencies with their respective computedValues.
+ * Note that all elements must have been previously registered otherwise errors will be thrown
+ * when trying to depend on something not in the store.
+ */
+export declare class DependencyProcessor {
+    protected readonly store: Store;
+    protected readonly eventManager: EventManager;
+    protected readonly taskRunner: TaskRunner;
+    protected readonly resourceInitializer: ResourceInitializer;
+    protected readonly logger: Logger;
+    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger);
+    /**
+     * This function is going to go through all the resources, tasks and middleware to compute their required dependencies.
+     */
+    computeAllDependencies(): Promise<void>;
+    private computeTaskDependencies;
+    initializeUninitializedResources(): Promise<void>;
+    /**
+     * Processes dependencies and hooks
+     * @param resource
+     */
+    protected processResourceDependencies<TD extends DependencyMapType>(resource: ResourceStoreElementType<any, any, TD>): Promise<void>;
+    private wrapResourceDependencies;
+    private makeTaskWithIntercept;
+    initializeRoot(): Promise<void>;
+    /**
+     * Processes all hooks, should run before emission of any event.
+     */
+    attachListeners(): void;
+    extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
+    extractDependency(object: any, source: string): Promise<any>;
+    /**
+     * Converts the event into a running functions with real inputs
+     * @param object
+     * @returns
+     */
+    extractEventDependency(object: IEvent<any>, source: string): (input: any) => Promise<void>;
+    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown) => Promise<any>>;
+    extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
+}

package/dist/models/EventManager.d.ts

@@ -0,0 +1,153 @@
+import { DependencyValuesType, EventHandlerType, IEvent, IEventEmission } from "../defs";
+import { IHook } from "../types/hook";
+/**
+ * Options for configuring event listeners
+ */
+export interface IEventHandlerOptions<T = any> {
+    order?: number;
+    filter?: (event: IEventEmission<T>) => boolean;
+    /**
+     * Represents the listener ID. Use this to avoid a listener calling himself.
+     */
+    id?: string;
+}
+/**
+ * Interceptor for event emissions
+ */
+export type EventEmissionInterceptor = (next: (event: IEventEmission<any>) => Promise<void>, event: IEventEmission<any>) => Promise<void>;
+/**
+ * Interceptor for hook execution
+ */
+export type HookExecutionInterceptor = (next: (hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>, hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>;
+/**
+ * EventManager handles event emission, listener registration, and event processing.
+ * It supports both specific event listeners and global listeners that handle all events.
+ * Listeners are processed in order based on their priority.
+ */
+export declare class EventManager {
+    #private;
+    private listeners;
+    private globalListeners;
+    private cachedMergedListeners;
+    private globalListenersCacheValid;
+    private emissionInterceptors;
+    private hookInterceptors;
+    private readonly emissionStack;
+    private readonly currentHookIdContext;
+    private readonly runtimeCycleDetection;
+    constructor(options?: {
+        runtimeCycleDetection?: boolean;
+    });
+    /**
+     * Gets the current lock status of the EventManager
+     */
+    get isLocked(): boolean;
+    /**
+     * Locks the EventManager, preventing any further modifications to listeners
+     */
+    lock(): void;
+    /**
+     * Emits an event to all registered listeners for that event type.
+     * Listeners are processed in order of priority and can stop event propagation.
+     *
+     * @param eventDefinition - The event definition to emit
+     * @param data - The event payload data
+     * @param source - The source identifier of the event emitter
+     */
+    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<void>;
+    /**
+     * Registers an event listener for specific event(s).
+     * Listeners are ordered by priority and executed in ascending order.
+     *
+     * @param event - The event definition(s) to listen for
+     * @param handler - The callback function to handle the event
+     * @param options - Configuration options for the listener
+     */
+    addListener<T>(event: IEvent<T> | Array<IEvent<T>>, handler: EventHandlerType<T>, options?: IEventHandlerOptions<T>): void;
+    /**
+     * Registers a global event listener that handles all events.
+     * Global listeners are mixed with specific listeners and ordered by priority.
+     *
+     * @param handler - The callback function to handle events
+     * @param options - Configuration options for the listener
+     */
+    addGlobalListener(handler: EventHandlerType, options?: IEventHandlerOptions): void;
+    /**
+     * Checks if there are any listeners registered for the given event
+     *
+     * @param eventDefinition - The event definition to check
+     * @returns true if listeners exist, false otherwise
+     */
+    hasListeners<T>(eventDefinition: IEvent<T>): boolean;
+    /**
+     * Adds an interceptor for all event emissions
+     * Interceptors are executed in the order they are added, with the ability to
+     * modify, log, or prevent event emissions
+     *
+     * @param interceptor - The interceptor function to add
+     */
+    intercept(interceptor: EventEmissionInterceptor): void;
+    /**
+     * Adds an interceptor for hook execution
+     * Interceptors are executed in the order they are added, with the ability to
+     * modify, log, or prevent hook execution
+     *
+     * @param interceptor - The interceptor function to add
+     */
+    interceptHook(interceptor: HookExecutionInterceptor): void;
+    /**
+     * Executes a hook with all registered hook interceptors applied
+     * This method should be used by TaskRunner when executing hooks
+     *
+     * @param hook - The hook to execute
+     * @param event - The event that triggered the hook
+     * @param computedDependencies - The computed dependencies for the hook
+     * @returns Promise resolving to the hook execution result
+     */
+    executeHookWithInterceptors(hook: IHook<any, any>, event: IEventEmission<any>, computedDependencies: DependencyValuesType<any>): Promise<any>;
+    /**
+     * Throws an error if the EventManager is locked
+     */
+    private checkLock;
+    /**
+     * Merges two sorted arrays of listeners while maintaining order.
+     * Used to combine event-specific listeners with global listeners.
+     *
+     * @param a - First array of listeners
+     * @param b - Second array of listeners
+     * @returns Merged and sorted array of listeners
+     */
+    private mergeSortedListeners;
+    /**
+     * Inserts a new listener into a sorted array using binary search.
+     * Maintains order based on listener priority.
+     *
+     * @param listeners - Array to insert into
+     * @param newListener - Listener to insert
+     */
+    private insertListener;
+    /**
+     * Returns true if the given emission carries the tag that marks
+     * it as excluded from global ("*") listeners.
+     *
+     * @param event - The event emission to check
+     * @returns true if event should exclude global listeners
+     */
+    private isExcludedFromGlobal;
+    /**
+     * Retrieves cached merged listeners for an event, or creates them if not cached.
+     * Combines event-specific listeners with global listeners and sorts them by priority.
+     *
+     * @param eventId - The event ID to get listeners for
+     * @returns Array of merged listeners sorted by priority
+     */
+    private getCachedMergedListeners;
+    /**
+     * Invalidates the cached merged listeners.
+     * If eventId is provided, only invalidates cache for that specific event.
+     * Otherwise, invalidates the global cache.
+     *
+     * @param eventId - Optional specific event ID to invalidate
+     */
+    private invalidateCache;
+}

package/dist/models/LogPrinter.d.ts

@@ -0,0 +1,55 @@
+export type PrintStrategy = "pretty" | "plain" | "json" | "json_pretty";
+export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critical";
+export interface PrintableLog {
+    level: LogLevels;
+    source?: string;
+    message: any;
+    timestamp: Date;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    data?: Record<string, any>;
+    context?: Record<string, any>;
+}
+export type ColorTheme = {
+    trace: string;
+    debug: string;
+    info: string;
+    warn: string;
+    error: string;
+    critical: string;
+    reset: string;
+    bold: string;
+    dim: string;
+    blue: string;
+    cyan: string;
+    gray: string;
+};
+export declare class LogPrinter {
+    private strategy;
+    private colors;
+    constructor(options: {
+        strategy: PrintStrategy;
+        useColors: boolean;
+        colorTheme?: Partial<ColorTheme>;
+    });
+    print(log: PrintableLog): void;
+    private pickWriter;
+    private formatTime;
+    private formatLevel;
+    private formatSource;
+    private formatMessage;
+    private formatError;
+    private formatData;
+    private formatContext;
+    private normalizeForJson;
+    private static NO_COLORS;
+    private static writers;
+    static setWriters(writers: Partial<{
+        log: (msg: any) => void;
+        error?: (msg: any) => void;
+    }>): void;
+    static resetWriters(): void;
+}

package/dist/models/Logger.d.ts

@@ -0,0 +1,85 @@
+import { LogPrinter, PrintStrategy as PrinterStrategy } from "./LogPrinter";
+export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critical";
+export interface ILogInfo {
+    source?: string;
+    error?: unknown | Error;
+    data?: Record<string, any>;
+    context?: Record<string, any>;
+    [key: string]: any;
+}
+export interface ILog {
+    level: LogLevels;
+    source?: string;
+    message: any;
+    timestamp: Date;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    data?: Record<string, any>;
+    context?: Record<string, any>;
+}
+export type PrintStrategy = PrinterStrategy;
+export declare class Logger {
+    private printThreshold;
+    private printStrategy;
+    private bufferLogs;
+    private buffer;
+    private boundContext;
+    private isLocked;
+    private useColors;
+    private printer;
+    private source?;
+    private rootLogger?;
+    localListeners: Array<(log: ILog) => void | Promise<void>>;
+    static Severity: {
+        trace: number;
+        debug: number;
+        info: number;
+        warn: number;
+        error: number;
+        critical: number;
+    };
+    constructor(options: {
+        printThreshold: null | LogLevels;
+        printStrategy: PrintStrategy;
+        bufferLogs: boolean;
+        useColors?: boolean;
+    }, boundContext?: Record<string, any>, source?: string, printer?: LogPrinter);
+    private detectColorSupport;
+    /**
+     * Creates a new logger instance with additional bound context
+     */
+    with({ source, additionalContext: context, }: {
+        source?: string;
+        additionalContext?: Record<string, any>;
+    }): Logger;
+    /**
+     * Core logging method with structured LogInfo
+     */
+    log(level: LogLevels, message: any, logInfo?: ILogInfo): Promise<void>;
+    private extractErrorInfo;
+    info(message: any, logInfo?: ILogInfo): Promise<void>;
+    error(message: any, logInfo?: ILogInfo): Promise<void>;
+    warn(message: any, logInfo?: ILogInfo): Promise<void>;
+    debug(message: any, logInfo?: ILogInfo): Promise<void>;
+    trace(message: any, logInfo?: ILogInfo): Promise<void>;
+    critical(message: any, logInfo?: ILogInfo): Promise<void>;
+    /**
+     * Direct print for tests and advanced scenarios. Delegates to LogPrinter.
+     */
+    print(log: ILog): void;
+    /**
+     * @param listener - A listener that will be triggered for every log.
+     */
+    onLog(listener: (log: ILog) => any): void;
+    /**
+     * Marks the logger as ready.
+     * This is used to trigger the local listeners and print the buffered logs (if they exists)
+     * @returns A promise that resolves when the logger is ready.
+     */
+    lock(): Promise<void>;
+    private canPrint;
+    private triggerLogListeners;
+}

package/dist/models/MiddlewareManager.d.ts

@@ -0,0 +1,86 @@
+import { DependencyMapType, ITask, IResource, ITaskMiddleware } from "../defs";
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+import { Logger } from "./Logger";
+import { ITaskMiddlewareExecutionInput } from "../types/taskMiddleware";
+import { IResourceMiddlewareExecutionInput, IResourceMiddleware } from "../types/resourceMiddleware";
+/**
+ * Interceptor for task middleware execution
+ */
+export type TaskMiddlewareInterceptor = (next: (input: ITaskMiddlewareExecutionInput<any>) => Promise<any>, input: ITaskMiddlewareExecutionInput<any>) => Promise<any>;
+/**
+ * Interceptor for resource middleware execution
+ */
+export type ResourceMiddlewareInterceptor = (next: (input: IResourceMiddlewareExecutionInput<any>) => Promise<any>, input: IResourceMiddlewareExecutionInput<any>) => Promise<any>;
+/**
+ * Centralizes middleware composition and execution for both tasks and resources.
+ * Keeps observability emissions and unhandled error routing consistent.
+ */
+export declare class MiddlewareManager {
+    #private;
+    protected readonly store: Store;
+    protected readonly eventManager: EventManager;
+    protected readonly logger: Logger;
+    private taskMiddlewareInterceptors;
+    private resourceMiddlewareInterceptors;
+    private perMiddlewareInterceptors;
+    private perResourceMiddlewareInterceptors;
+    constructor(store: Store, eventManager: EventManager, logger: Logger);
+    /**
+     * Gets the current lock status of the MiddlewareManager
+     */
+    get isLocked(): boolean;
+    /**
+     * Locks the MiddlewareManager, preventing any further modifications to interceptors
+     */
+    lock(): void;
+    /**
+     * Throws an error if the MiddlewareManager is locked
+     */
+    private checkLock;
+    /**
+     * Adds an interceptor for task or resource middleware execution
+     * Interceptors are executed in the order they are added, with the ability to
+     * modify, log, or prevent middleware execution
+     *
+     * @param kind - The type of middleware to intercept ("task" or "resource")
+     * @param interceptor - The interceptor function to add
+     */
+    intercept(kind: "task" | "resource", interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
+    /**
+     * Adds an interceptor for a specific middleware instance with better type safety
+     * This method automatically determines the type and provides type-safe access
+     *
+     * @param middleware - The middleware instance to intercept
+     * @param interceptor - The interceptor function with proper typing
+     */
+    interceptMiddleware(middleware: ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any>, interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
+    /**
+     * Wrap a middleware with its specific interceptors in onion style
+     */
+    private wrapMiddlewareWithInterceptors;
+    /**
+     * Wrap a resource middleware with its specific interceptors in onion style
+     */
+    private wrapResourceMiddlewareWithInterceptors;
+    /**
+     * Compose a runner for a task with its local interceptors and applicable middlewares.
+     * Returns a function that accepts the task input and resolves to the task output.
+     */
+    composeTaskRunner<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: any) => Promise<TOutput | (TOutput extends Promise<infer U> ? U : never)>;
+    /**
+     * Run a resource init wrapped with its applicable middlewares.
+     */
+    runResourceInit<C, V extends Promise<any>, D extends DependencyMapType, TContext>(resource: IResource<C, V, D, TContext>, config: C, dependencies: any, context: TContext): Promise<V | undefined>;
+    private getApplicableTaskMiddlewares;
+    private getApplicableResourceMiddlewares;
+    /**
+     * @param task
+     * @returns
+     */
+    getEverywhereMiddlewareForTasks(task: ITask<any, any, any, any>): ITaskMiddleware[];
+    /**
+     * Returns all global middleware for resource, which do not depend on the target resource.
+     */
+    getEverywhereMiddlewareForResources(target: IResource<any, any, any, any>): IResourceMiddleware[];
+}

package/dist/models/OverrideManager.d.ts

@@ -0,0 +1,13 @@
+import { IResource, ITaskMiddleware, IResourceMiddleware, ITask, IResourceWithConfig, RegisterableItems, IHook } from "../defs";
+import { StoreRegistry } from "./StoreRegistry";
+export declare class OverrideManager {
+    private readonly registry;
+    overrides: Map<string, IResource | ITaskMiddleware | IResourceMiddleware | ITask | IResourceWithConfig | IHook>;
+    overrideRequests: Set<{
+        source: string;
+        override: RegisterableItems;
+    }>;
+    constructor(registry: StoreRegistry);
+    storeOverridesDeeply<C>(element: IResource<C, any, any>): void;
+    processOverrides(): void;
+}

package/dist/models/Queue.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cooperative task queue.
+ *  • Tasks run one‑after‑another (FIFO ordering).
+ *  • Dead‑lock detection prevents nesting.
+ *  • dispose() drains or cancels outstanding tasks, then rejects new ones.
+ */
+export declare class Queue {
+    private tail;
+    private disposed;
+    private abortController;
+    private readonly executionContext;
+    private readonly hasAsyncLocalStorage;
+    /**
+     * Schedule an asynchronous task.
+     * @param task – receives an AbortSignal so it can cancel early if desired.
+     */
+    run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    /**
+     * Disposes the queue.
+     * @param options.cancel – if true, broadcasts AbortSignal to running task.
+     *                         default: false (waits for tasks to finish).
+     */
+    dispose(options?: {
+        cancel?: boolean;
+    }): Promise<void>;
+}

package/dist/models/ResourceInitializer.d.ts

@@ -0,0 +1,20 @@
+import { DependencyMapType, IResource, ResourceDependencyValuesType } from "../defs";
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+import { Logger } from "./Logger";
+export declare class ResourceInitializer {
+    protected readonly store: Store;
+    protected readonly eventManager: EventManager;
+    protected readonly logger: Logger;
+    constructor(store: Store, eventManager: EventManager, logger: Logger);
+    private readonly middlewareManager;
+    /**
+     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+     * This function can throw only if any of the event listeners or run function throws
+     */
+    initializeResource<TConfig = null, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TContext = any>(resource: IResource<TConfig, TValue, TDeps>, config: TConfig, dependencies: ResourceDependencyValuesType<TDeps>): Promise<{
+        value: TValue;
+        context: TContext;
+    }>;
+    initWithMiddleware<C, V extends Promise<any>, D extends DependencyMapType, TContext>(resource: IResource<C, V, D, TContext>, config: C, dependencies: ResourceDependencyValuesType<D>, context: TContext): Promise<V | undefined>;
+}