@bluelibs/runner 5.4.0 → 5.5.0

package/dist/types/globals/resources/tunnel/plan.d.ts

@@ -1,4 +1,3 @@
-import type { ITaskMiddleware } from "../../../defs";
 export type ValidationSide = "client" | "server" | "both";
 export interface ExecutionPlan {
     clientMiddleware: string[];
@@ -12,8 +11,12 @@ export interface PlanMeta {
     context?: unknown;
 }
 export declare function computeExecutionPlanFromWhitelist(whitelist: {
-    client?: Array<string | ITaskMiddleware<any, any, any, any>>;
-    server?: Array<string | ITaskMiddleware<any, any, any, any>>;
+    client?: Array<string | {
+        id: string;
+    }>;
+    server?: Array<string | {
+        id: string;
+    }>;
 }, opts?: {
     defaultValidation?: ValidationSide;
 }): ExecutionPlan;

package/dist/types/globals/resources/tunnel/tunnel.policy.tag.d.ts

@@ -23,4 +23,6 @@ export interface TunnelTaskMiddlewarePolicyConfig {
         server?: TunnelMiddlewareId[];
     };
 }
+export declare const tunnelTaskPolicyTag: import("../../..").ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;
+/** @deprecated Use tunnelTaskPolicyTag instead. */
 export declare const tunnelPolicyTag: import("../../..").ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;

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

@@ -9,15 +9,20 @@ export type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<
 export type EventDeliveryMode = "mirror" | "remote-only" | "local-only" | "remote-first";
 export interface TunnelTagConfig {
 }
-export type TunnelTaskRunner = (task: ITask<any, any, any, any, any, any>, input?: any) => Promise<any>;
+export type TunnelTaskRunner = (task: ITask<any, any, any, any, any, any>, input?: unknown) => Promise<unknown>;
 export interface TunnelRunner {
     transport?: "http" | string;
     mode?: TunnelMode;
+    /**
+     * Controls whether server-side exposure hydrates incoming x-runner-context headers
+     * for task/event ids selected by this tunnel. Defaults to true.
+     */
+    allowAsyncContext?: boolean;
     tasks?: TunnelTaskSelector;
     events?: TunnelEventSelector;
     eventDeliveryMode?: EventDeliveryMode;
     run?: TunnelTaskRunner;
-    emit?: (event: IEventEmission<any>) => Promise<any>;
+    emit?: (event: IEventEmission<any>) => Promise<unknown>;
 }
 export interface ExposureFetchAuthConfig {
     header?: string;

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

@@ -1,15 +1,20 @@
 export * from "./resources/debug/types";
 export * from "./resources/tunnel/types";
+export type { CronResourceValue, CronScheduledTask, CronTagConfig, } from "./cron/types";
+export { CronOnError } from "./cron/types";
 export * from "./debug";
-export type { CacheResourceConfig } from "./middleware/cache.middleware";
+export type { CacheResourceConfig, ICacheInstance, } from "./middleware/cache.middleware";
+export type { CircuitBreakerOpenError } from "./middleware/circuitBreaker.middleware";
 export type { CircuitBreakerMiddlewareConfig, CircuitBreakerStatus, CircuitBreakerState, } from "./middleware/circuitBreaker.middleware";
 export type { ConcurrencyMiddlewareConfig, ConcurrencyState, } from "./middleware/concurrency.middleware";
 export type { FallbackMiddlewareConfig } from "./middleware/fallback.middleware";
 export type { RateLimitMiddlewareConfig, RateLimitState, } from "./middleware/rateLimit.middleware";
+export type { RateLimitError } from "./middleware/rateLimit.middleware";
 export type { RequireContextMiddlewareConfig } from "./middleware/requireContext.middleware";
 export type { RetryMiddlewareConfig } from "./middleware/retry.middleware";
 export type { DebounceState, TemporalMiddlewareConfig, ThrottleState, } from "./middleware/temporal.middleware";
 export type { TimeoutMiddlewareConfig } from "./middleware/timeout.middleware";
+export type { TimeoutError } from "./middleware/timeout.middleware";
 export type { TunnelMiddlewareId, TunnelTaskMiddlewareSidePolicy, TunnelTaskMiddlewarePolicyConfig, TunnelTaskMiddlewarePolicySideConfig, } from "./resources/tunnel/tunnel.policy.tag";
 export type { HttpClientFactoryConfig, HttpClientFactory, } from "./resources/httpClientFactory.resource";
 export type { HttpClientAuthConfig, HttpCreateClientConfig } from "./tunnels";

package/dist/types/models/BuiltinsRegistry.d.ts

@@ -0,0 +1,2 @@
+import type { StoreRegistry } from "./StoreRegistry";
+export declare function registerStoreBuiltins(registry: StoreRegistry): void;

package/dist/types/models/DependencyProcessor.d.ts

@@ -1,10 +1,14 @@
-import { DependencyMapType, DependencyValuesType, ITask, IResource, IEvent, TaskCallOptions } from "../defs";
+import { DependencyMapType, DependencyValuesType, IEvent, IEventEmission, IEventEmitOptions, IResource, ITask } 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";
+import { ResourceInitMode } from "../types/runner";
+import { DependencyExtractor } from "./dependency-processor/DependencyExtractor";
+import { HookEventBuffer } from "./dependency-processor/HookEventBuffer";
+import { ResourceScheduler } from "./dependency-processor/ResourceScheduler";
 /**
  * Resolves and caches computed dependencies for store items (resources, tasks, middleware, hooks).
  */
@@ -13,26 +17,43 @@ export declare class DependencyProcessor {
     protected readonly eventManager: EventManager;
     protected readonly taskRunner: TaskRunner;
     protected readonly resourceInitializer: ResourceInitializer;
+    protected readonly dependencyExtractor: DependencyExtractor;
+    protected readonly hookEventBuffer: HookEventBuffer;
+    protected readonly resourceScheduler: ResourceScheduler;
     protected readonly logger: Logger;
-    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger);
+    protected readonly initMode: ResourceInitMode;
+    protected readonly lazy: boolean;
+    readonly pendingHookEvents: Map<string, IEventEmission<any>[]>;
+    readonly drainingHookIds: Set<string>;
+    private readonly inFlightResourceInitializations;
+    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger, initMode?: ResourceInitMode, lazy?: boolean, runtimeEventCycleDetection?: boolean);
     /**
      * Computes and caches dependencies for all registered store items.
      */
     computeAllDependencies(): Promise<void>;
+    private initializeStartupRequiredResourcesParallel;
+    private collectStartupRequiredResourceIds;
     private computeTaskDependencies;
     initializeUninitializedResources(): Promise<void>;
+    private computeResourceMiddlewareDependencies;
+    private computeTaskMiddlewareDependencies;
+    private computeHookDependencies;
+    private initializeUninitializedResourcesParallel;
+    private ensureResourceInitialized;
+    private resetResourceInitializationState;
     private rethrowResourceInitError;
     /**
      * Computes and caches dependencies for a resource (if not already computed).
      */
     protected processResourceDependencies<TD extends DependencyMapType>(resource: ResourceStoreElementType<any, any, TD>): Promise<void>;
     private wrapResourceDependencies;
-    private makeTaskWithIntercept;
     initializeRoot(): Promise<void>;
     /**
      * Attaches listeners for all hooks. Must run before emitting events.
      */
     attachListeners(): void;
+    private enqueueBufferedHookEvent;
+    private flushBufferedHookEvents;
     extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
     extractDependency(object: unknown, source: string): Promise<any>;
     /**
@@ -40,7 +61,7 @@ export declare class DependencyProcessor {
      * @param object
      * @returns
      */
-    extractEventDependency(object: IEvent<any>, source: string): (input: any) => Promise<void>;
-    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown, options?: TaskCallOptions) => Promise<any>>;
+    extractEventDependency(object: IEvent<any>, source: string): (input: any, options?: IEventEmitOptions) => Promise<any>;
+    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown, options?: import("..").TaskCallOptions) => Promise<any>>;
     extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
 }

package/dist/types/models/EventManager.d.ts

@@ -1,4 +1,4 @@
-import { DependencyValuesType, EventHandlerType, IEvent, IEventEmission } from "../defs";
+import { DependencyValuesType, EventHandlerType, IEvent, IEventEmission, IEventEmitOptions, IEventEmitReport } from "../defs";
 import { IHook } from "../types/hook";
 import { EventEmissionInterceptor, HookExecutionInterceptor, IEventHandlerOptions } from "./event/types";
 /**
@@ -8,9 +8,6 @@ import { EventEmissionInterceptor, HookExecutionInterceptor, IEventHandlerOption
  */
 export declare class EventManager {
     #private;
-    private listeners;
-    private globalListeners;
-    private cachedMergedListeners;
     private emissionInterceptors;
     private hookInterceptors;
     private readonly registry;
@@ -36,6 +33,10 @@ export declare class EventManager {
      * @param source - The source identifier of the event emitter
      */
     emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<void>;
+    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string, options: IEventEmitOptions & {
+        report: true;
+    }): Promise<IEventEmitReport>;
+    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string, options?: IEventEmitOptions): Promise<void | IEventEmitReport>;
     /**
      * Emits an event and returns the final payload.
      * The payload is taken from the deepest emission object that reached either:
@@ -63,6 +64,10 @@ export declare class EventManager {
      * @param options - Configuration options for the listener
      */
     addGlobalListener(handler: EventHandlerType, options?: IEventHandlerOptions): void;
+    /**
+     * Removes listeners registered with the provided listener id.
+     */
+    removeListenerById(id: string): void;
     /**
      * Checks if there are any listeners registered for the given event
      *
@@ -105,11 +110,6 @@ export declare class EventManager {
      * Disposes the EventManager, releasing all listeners and interceptors.
      */
     dispose(): void;
-    /**
-     * Retrieves cached merged listeners for an event, or creates them if not cached.
-     * Kept for backward compatibility (tests spy on this).
-     */
-    private getCachedMergedListeners;
 }
 export type { IEventHandlerOptions };
 export type { EventEmissionInterceptor, HookExecutionInterceptor };

package/dist/types/models/LogPrinter.d.ts

@@ -3,15 +3,15 @@ export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critica
 export interface PrintableLog {
     level: LogLevels;
     source?: string;
-    message: any;
+    message: unknown;
     timestamp: Date;
     error?: {
         name: string;
         message: string;
         stack?: string;
     };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
+    data?: Record<string, unknown>;
+    context?: Record<string, unknown>;
 }
 export type ColorTheme = {
     trace: string;
@@ -49,8 +49,8 @@ export declare class LogPrinter {
     private static readonly DEFAULT_WRITERS;
     private static writers;
     static setWriters(writers: Partial<{
-        log: (msg: any) => void;
-        error?: (msg: any) => void;
+        log: (msg: string) => void;
+        error?: (msg: string) => void;
     }>): void;
     static resetWriters(): void;
 }

package/dist/types/models/Logger.d.ts

@@ -3,22 +3,22 @@ export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critica
 export interface ILogInfo {
     source?: string;
     error?: unknown | Error;
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-    [key: string]: any;
+    data?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    [key: string]: unknown;
 }
 export interface ILog {
     level: LogLevels;
     source?: string;
-    message: any;
+    message: unknown;
     timestamp: Date;
     error?: {
         name: string;
         message: string;
         stack?: string;
     };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
+    data?: Record<string, unknown>;
+    context?: Record<string, unknown>;
 }
 export type PrintStrategy = PrinterStrategy;
 export declare class Logger {
@@ -46,26 +46,26 @@ export declare class Logger {
         printStrategy: PrintStrategy;
         bufferLogs: boolean;
         useColors?: boolean;
-    }, boundContext?: Record<string, any>, source?: string, printer?: LogPrinter);
+    }, boundContext?: Record<string, unknown>, 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>;
+        additionalContext?: Record<string, unknown>;
     }): Logger;
     /**
      * Core logging method with structured LogInfo
      */
-    log(level: LogLevels, message: any, logInfo?: ILogInfo): Promise<void>;
+    log(level: LogLevels, message: unknown, 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>;
+    info(message: unknown, logInfo?: ILogInfo): Promise<void>;
+    error(message: unknown, logInfo?: ILogInfo): Promise<void>;
+    warn(message: unknown, logInfo?: ILogInfo): Promise<void>;
+    debug(message: unknown, logInfo?: ILogInfo): Promise<void>;
+    trace(message: unknown, logInfo?: ILogInfo): Promise<void>;
+    critical(message: unknown, logInfo?: ILogInfo): Promise<void>;
     /**
      * Direct print for tests and advanced scenarios. Delegates to LogPrinter.
      */
@@ -73,7 +73,7 @@ export declare class Logger {
     /**
      * @param listener - A listener that will be triggered for every log.
      */
-    onLog(listener: (log: ILog) => any): void;
+    onLog(listener: (log: ILog) => void | Promise<void>): void;
     /**
      * Marks the logger as ready.
      * This is used to trigger the local listeners and print the buffered logs (if they exists)

package/dist/types/models/MiddlewareManager.d.ts

@@ -1,6 +1,7 @@
 import { DependencyMapType, ITask, IResource, ResourceDependencyValuesType } from "../defs";
 import { Store } from "./Store";
 import { ITaskMiddleware, IResourceMiddleware } from "../defs";
+import type { InterceptorOwnerSnapshot } from "./middleware/InterceptorRegistry";
 import { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor } from "./middleware/types";
 export type { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor };
 /**
@@ -42,6 +43,12 @@ export declare class MiddlewareManager {
      */
     intercept(kind: "task", interceptor: TaskMiddlewareInterceptor): void;
     intercept(kind: "resource", interceptor: ResourceMiddlewareInterceptor): void;
+    /**
+     * @internal
+     * Same behavior as intercept(), but records owner metadata for tooling.
+     */
+    interceptOwned(kind: "task", interceptor: TaskMiddlewareInterceptor, ownerResourceId?: string): void;
+    interceptOwned(kind: "resource", interceptor: ResourceMiddlewareInterceptor, ownerResourceId?: string): void;
     /**
      * Adds an interceptor for a specific middleware instance with better type safety
      * This method automatically determines the type and provides type-safe access
@@ -51,6 +58,17 @@ export declare class MiddlewareManager {
      */
     interceptMiddleware(middleware: ITaskMiddleware<any, any, any, any>, interceptor: TaskMiddlewareInterceptor): void;
     interceptMiddleware(middleware: IResourceMiddleware<any, any, any, any>, interceptor: ResourceMiddlewareInterceptor): void;
+    /**
+     * @internal
+     * Same behavior as interceptMiddleware(), but records owner metadata for tooling.
+     */
+    interceptMiddlewareOwned(middleware: ITaskMiddleware<any, any, any, any>, interceptor: TaskMiddlewareInterceptor, ownerResourceId?: string): void;
+    interceptMiddlewareOwned(middleware: IResourceMiddleware<any, any, any, any>, interceptor: ResourceMiddlewareInterceptor, ownerResourceId?: string): void;
+    /**
+     * @internal
+     * Snapshot of resource owners that registered middleware interceptors.
+     */
+    getInterceptorOwnerSnapshot(): InterceptorOwnerSnapshot;
     /**
      * 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.

package/dist/types/models/OverrideManager.d.ts

@@ -8,6 +8,9 @@ export declare class OverrideManager {
         override: RegisterableItems;
     }>;
     constructor(registry: StoreRegistry);
-    storeOverridesDeeply<C>(element: IResource<C, any, any>): void;
+    private getOverrideId;
+    private getOverrideType;
+    private getOverrideSourcesById;
+    storeOverridesDeeply<C>(element: IResource<C, any, any>, visited?: Set<string>): void;
     processOverrides(): void;
 }

package/dist/types/models/Queue.d.ts

@@ -14,6 +14,7 @@ export type QueueEvent = {
 export declare class Queue {
     private tail;
     private disposed;
+    private pendingTaskCount;
     private abortController;
     private readonly eventManager;
     private nextTaskId;
@@ -36,5 +37,6 @@ export declare class Queue {
     }): Promise<void>;
     on(type: QueueEventType, handler: (event: QueueEvent) => any): () => void;
     once(type: QueueEventType, handler: (event: QueueEvent) => any): () => void;
+    isIdle(): boolean;
     private emit;
 }