@bluelibs/runner 4.8.6 → 4.9.0

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

@@ -1,11 +0,0 @@
-import type { ExposureFetchConfig, ExposureFetchClient } from "./globals/resources/tunnel/types";
-export { normalizeError } from "./globals/resources/tunnel/error-utils";
-export type { ExposureFetchAuthConfig, ExposureFetchConfig, ExposureFetchClient, } from "./globals/resources/tunnel/types";
-/**
- * This functions communicates with the exposure server over HTTP.
- * It uses the @readmes/TUNNEL_HTTP_POLICY.md strategy.
- *
- * @param cfg
- * @returns
- */
-export declare function createExposureFetch(cfg: ExposureFetchConfig): ExposureFetchClient;

package/dist/index.d.ts

@@ -1,117 +0,0 @@
-import { defineTask, defineResource, defineEvent, defineTaskMiddleware, defineResourceMiddleware, defineTag, defineOverride, defineHook } from "./define";
-import { defineAsyncContext, createContext as oldCreateContext } from "./definers/defineAsyncContext";
-import { run } from "./run";
-import { createTestResource } from "./testing";
-declare const globals: {
-    events: {
-        readonly ready: import(".").IEvent<void>;
-    };
-    resources: {
-        readonly store: import(".").IResource<void, Promise<import("./models").Store>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly middlewareManager: import(".").IResource<void, Promise<import("./models").MiddlewareManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly eventManager: import(".").IResource<void, Promise<import("./models").EventManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly taskRunner: import(".").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly logger: import(".").IResource<void, Promise<import("./models").Logger>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly serializer: import(".").IResource<void, Promise<import(".").Serializer>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly 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[]>;
-        readonly 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[]>;
-        readonly httpClientFactory: import(".").IResource<void, Promise<import(".").HttpClientFactory>, {
-            serializer: import(".").IResource<void, Promise<import(".").Serializer>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-            store: import(".").IResource<void, Promise<import("./models").Store>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        }, any, {
-            title: string;
-            description: string;
-        }, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-    };
-    middleware: {
-        requireContext: import(".").ITaskMiddleware<{
-            context: import(".").IAsyncContext<any>;
-        }, void, void, any>;
-        task: {
-            requireContext: import(".").ITaskMiddleware<{
-                context: import(".").IAsyncContext<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(".").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;
-        }>;
-    }>;
-    debug: {
-        levels: {
-            normal: import(".").DebugConfig;
-            verbose: import(".").DebugConfig;
-        };
-    };
-};
-export { globals };
-export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineAsyncContext as asyncContext, defineTag as tag, defineOverride as override, defineHook as hook, run, createTestResource, };
-declare const createContext: typeof oldCreateContext;
-export { createContext };
-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;
-    asyncContext: typeof import("./definers/builders/asyncContext").asyncContextBuilder;
-    error: typeof import("./definers/builders/error").errorBuilder;
-    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 { PlatformAdapter, setPlatform } from "./platform";
-export { EJSON } from "@bluelibs/ejson";
-export * from "./http-client";
-export * from "./http-fetch-tunnel.resource";
-export type * from "./defs";

package/dist/models/DependencyProcessor.d.ts

@@ -1,48 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,75 +0,0 @@
-import { DependencyMapType, ITask, IResource } from "../defs";
-import { EventManager } from "./EventManager";
-import { Store } from "./Store";
-import { Logger } from "./Logger";
-import { ITaskMiddleware, IResourceMiddleware } from "../defs";
-import { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor } from "./middleware/types";
-export type { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor };
-/**
- * Centralizes middleware composition and execution for both tasks and resources.
- * Keeps observability emissions and unhandled error routing consistent.
- *
- * This is a facade that delegates to specialized composer classes for maintainability.
- */
-export declare class MiddlewareManager {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    private readonly interceptorRegistry;
-    private readonly middlewareResolver;
-    private readonly taskComposer;
-    private readonly resourceComposer;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    /**
-     * @internal
-     */
-    get taskMiddlewareInterceptors(): TaskMiddlewareInterceptor[];
-    /**
-     * @internal
-     */
-    get resourceMiddlewareInterceptors(): ResourceMiddlewareInterceptor[];
-    /**
-     * Gets the current lock status of the MiddlewareManager
-     */
-    get isLocked(): boolean;
-    /**
-     * Locks the MiddlewareManager, preventing any further modifications to interceptors
-     */
-    lock(): void;
-    /**
-     * 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;
-    /**
-     * 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: TInput) => Promise<Awaited<TOutput>>;
-    /**
-     * 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>;
-    /**
-     * Gets all "everywhere" middlewares that apply to the given task
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForTasks(task: ITask<any, any, any>): ITaskMiddleware[];
-    /**
-     * Gets all "everywhere" middlewares that apply to the given resource
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForResources(resource: IResource<any, any, any, any>): IResourceMiddleware[];
-}

package/dist/models/OverrideManager.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-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>;
-}

package/dist/models/RunResult.d.ts

@@ -1,35 +0,0 @@
-import { DependencyMapType, IEvent, ITask } from "../defs";
-import { IResource } from "../defs";
-import { EventManager } from "./EventManager";
-import { Logger } from "./Logger";
-import { Store } from "./Store";
-import { TaskRunner } from "./TaskRunner";
-export declare class RunResult<V> {
-    readonly value: V;
-    readonly logger: Logger;
-    readonly store: Store;
-    private readonly eventManager;
-    private readonly taskRunner;
-    private readonly disposeFn;
-    constructor(value: V, logger: Logger, store: Store, eventManager: EventManager, taskRunner: TaskRunner, disposeFn: () => Promise<void>);
-    /**
-     * Run a task within the context of the run result.
-     * @param task - The task to run.
-     * @param args - The arguments to pass to the task.
-     * @returns The result of the task.
-     */
-    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = any>(task: ITask<I, O, D> | string, ...args: I extends undefined | void ? [] : [I]) => Promise<O | undefined>;
-    /**
-     * Emit an event within the context of the run result.
-     * @param event - The event to emit.
-     * @param payload - The payload to emit.
-     */
-    emitEvent: <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P) => Promise<void>;
-    /**
-     * Get the value of a resource from the run result.
-     * @param resource - The resource to get the value of.
-     * @returns The value of the resource.
-     */
-    getResourceValue: <Output extends Promise<any>>(resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
-    dispose: () => Promise<void>;
-}