@bluelibs/runner 5.4.0 → 5.5.0

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

@@ -1,41 +1,305 @@
-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;
+import { IEvent, IEventEmitOptions, IEventEmitReport, IResource, ITask } from "../defs";
+import { IRuntime } from "../types/runner";
+import type { TaskCallOptions } from "../types/utilities";
+import type { EventManager } from "./EventManager";
+import type { Logger } from "./Logger";
+import type { Store } from "./Store";
+import type { TaskRunner } from "./TaskRunner";
+/**
+ * Options for configuring lazy resource loading behavior.
+ * Used to enable on-demand resource initialization to improve startup time.
+ */
+type RunResultLazyOptions = {
+    /**
+     * Whether lazy loading mode is enabled.
+     * When true, resources not used at startup are not initialized until accessed.
+     */
+    lazyMode?: boolean;
+    /**
+     * Set of resource IDs that were not initialized at startup.
+     * These resources require lazy loading to be accessed.
+     */
+    startupUnusedResourceIds?: ReadonlySet<string>;
+    /**
+     * Custom loader function for lazy resource initialization.
+     * Called when accessing a resource that hasn't been initialized yet.
+     */
+    lazyResourceLoader?: <T>(resourceId: string) => Promise<T>;
+};
+/**
+ * RunResult represents the runtime instance after executing `run(root)`.
+ * It provides access to tasks, events, resources, and lifecycle management.
+ *
+ * Key features:
+ * - Task execution via `runTask()`
+ * - Event emission via `emitEvent()`
+ * - Resource access via `getResourceValue()` / `getLazyResourceValue()`
+ * - Root access via `getRootValue()`, `getRootConfig()`, `getRootId()`
+ * - Disposal via `dispose()`
+ *
+ * @example
+ * const runtime = await run(app);
+ * const result = await runtime.runTask(myTask, { input: "data" });
+ * await runtime.dispose();
+ */
+export declare class RunResult<V> implements IRuntime<V> {
+    #private;
+    /**
+     * Framework logger for diagnostics and debugging.
+     * Use this for logging within tasks or hooks.
+     */
     readonly logger: Logger;
+    /**
+     * Central store containing all registered definitions.
+     * Provides access to tasks, events, resources, and their metadata.
+     */
     readonly store: Store;
+    /**
+     * Event manager for emitting events and triggering hooks.
+     * Handles both sync and async event propagation.
+     */
     private readonly eventManager;
+    /**
+     * Task runner that executes tasks with middleware pipeline.
+     * Handles dependency injection, validation, and error handling.
+     */
     private readonly taskRunner;
+    /**
+     * Function to call during disposal.
+     * Disposes all resources in reverse initialization order.
+     */
     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.
+     * Options for lazy resource loading mode.
+     * When enabled, unused resources are not initialized until accessed.
+     */
+    private lazyOptions;
+    /**
+     * Creates a new RunResult instance.
+     *
+     * @param logger - The framework logger for runtime diagnostics
+     * @param store - The central store containing all registered tasks, events, resources
+     * @param eventManager - Handles event emission and hook execution
+     * @param taskRunner - Executes tasks with middleware and validation
+     * @param disposeFn - Callback to clean up all resources during disposal
+     */
+    constructor(
+    /**
+     * Framework logger for diagnostics and debugging.
+     * Use this for logging within tasks or hooks.
+     */
+    logger: Logger, 
+    /**
+     * Central store containing all registered definitions.
+     * Provides access to tasks, events, resources, and their metadata.
+     */
+    store: Store, 
+    /**
+     * Event manager for emitting events and triggering hooks.
+     * Handles both sync and async event propagation.
+     */
+    eventManager: EventManager, 
+    /**
+     * Task runner that executes tasks with middleware pipeline.
+     * Handles dependency injection, validation, and error handling.
+     */
+    taskRunner: TaskRunner, 
+    /**
+     * Function to call during disposal.
+     * Disposes all resources in reverse initialization order.
+     */
+    disposeFn: () => Promise<void>);
+    /**
+     * Returns the root value initialized by the root resource.
+     * Only available after the root resource has been initialized.
+     */
+    get value(): V;
+    /**
+     * Ensures the runtime is active and can accept operations.
+     * Throws if the runtime has been disposed or is currently disposing.
+     * @internal
+     */
+    private ensureRuntimeIsActive;
+    /**
+     * Retrieves the root resource from the store.
+     * Throws if the root hasn't been set (e.g., during early access).
+     * @internal
+     */
+    private getRootOrThrow;
+    /**
+     * Configures lazy loading options for resources.
+     * Used to enable on-demand resource initialization.
+     * @param options - Lazy mode configuration
+     */
+    setLazyOptions(options: RunResultLazyOptions): void;
+    /**
+     * Sets the root value after the root resource initializes.
+     * @param value - The initialized root value
+     */
+    setValue(value: V | undefined): void;
+    /**
+     * Executes a registered task within the runtime context.
+     *
+     * The task runs through its full middleware pipeline including:
+     * - Input validation (via inputSchema)
+     - Middleware (retry, cache, timeout, etc.)
+     - The task's core logic
+     - Result validation (via resultSchema)
+     *
+     * @example
+     * // Run with task definition
+     * const result = await runtime.runTask(createUser, { name: "Alice" });
+     *
+     * // Run with options for journal forwarding
+     * const result = await runtime.runTask(greet, undefined, { journal });
+     */
+    runTask: <TTask extends ITask<any, Promise<any>, any> | string>(task: TTask, ...args: TTask extends ITask<infer I, any, any> ? I extends undefined | void ? [input?: I, options?: TaskCallOptions] : [input: I, options?: TaskCallOptions] : [input?: unknown, options?: TaskCallOptions]) => TTask extends ITask<any, infer O, any> ? O : Promise<any>;
+    /**
+     * Emits an event to trigger all registered hooks listening for it.
+     *
+     * Events are emitted synchronously or asynchronously depending on hook configuration.
+     * Hooks execute in order based on their `order()` value (lower runs first).
+     *
+     * @param event - The event definition or event ID string to emit
+     * @param payload - The event payload data
+     * @param options - Emission options (failureMode, throwOnError, report)
+     * @returns Promise<void> by default, or IEventEmitReport if report: true
+     *
+     * @example
+     * // Basic emission
+     * await runtime.emitEvent(userRegistered, { userId: "123", email: "a@b.com" });
+     *
+     * // With report for hook failure tracking
+     * const report = await runtime.emitEvent(notify, undefined, { report: true });
+     * if (report.failedListeners.length > 0) {
+     *   console.error("Failed hooks:", report.failedListeners);
+     * }
+     */
+    emitEvent: {
+        <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P): Promise<void>;
+        <P>(event: IEvent<P> | string, payload: P extends undefined | void ? undefined : P, options: IEventEmitOptions & {
+            report: true;
+        }): Promise<IEventEmitReport>;
+        <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P, options?: IEventEmitOptions): Promise<void | IEventEmitReport>;
+    };
+    /**
+     * Synchronously retrieves the initialized value of a resource.
+     *
+     * The resource must have been initialized (either at startup or via lazy loading).
+     * For resources not initialized at startup, use `getLazyResourceValue()` instead.
+     *
+     * @param resource - The resource definition or resource ID string
+     * @returns The initialized value of the resource (unwrapped if Promise-based)
+     * @throws RuntimeError if resource not found, not initialized, or runtime disposed
+     *
+     * @example
+     * // Get initialized resource
+     * const db = runtime.getResourceValue(database);
+     * const config = runtime.getResourceValue("app.config");
+     */
+    getResourceValue: <Output extends Promise<any>>(
+    /**
+     * The resource to retrieve. Can be:
+     * - A resource definition object (IResource)
+     * - A resource ID string (for dynamic lookup)
+     */
+    resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
+    /**
+     * Initializes (if not already) and returns the value of a resource on-demand.
+     *
+     * This method is useful when:
+     * - Lazy loading is enabled and the resource wasn't initialized at startup
+     * - You need to access a resource that may not have been loaded yet
+     * - You want to ensure initialization happens before access
+     *
+     * @param resource - The resource definition or resource ID string
+     * @returns The initialized value of the resource (unwrapped if Promise-based)
+     * @throws RuntimeError if resource not found or runtime disposed
+     *
+     * @example
+     * // Lazy-load a resource on demand
+     * const heavyService = await runtime.getLazyResourceValue(heavyService);
+     */
+    getLazyResourceValue: <Output extends Promise<any>>(
+    /**
+     * The resource to retrieve. Can be:
+     * - A resource definition object (IResource)
+     * - A resource ID string (for dynamic lookup)
+     */
+    resource: string | IResource<any, Output, any, any, any>) => Promise<Output extends Promise<infer U> ? U : Output>;
+    /**
+     * Retrieves the configuration that was passed to a resource.
+     *
+     * This returns the config object (the input), not the initialized value.
+     * Use `getResourceValue()` to get the initialized value.
+     *
+     * @param resource - The resource definition or resource ID string
+     * @returns The config object passed when registering the resource
+     * @throws RuntimeError if resource not found or runtime disposed
+     *
+     * @example
+     * const config = runtime.getResourceConfig(server);
+     * // config = { port: 3000 }
+     */
+    getResourceConfig: <Config>(
+    /**
+     * The resource to retrieve config from. Can be:
+     * - A resource definition object (IResource)
+     * - A resource ID string (for dynamic lookup)
+     */
+    resource: string | IResource<Config, any, any, any, any>) => Config;
+    /**
+     * Returns the ID of the root resource.
+     * @returns The root resource identifier
+     *
+     * @example
+     * const rootId = runtime.getRootId(); // "app"
+     */
+    getRootId: () => string;
+    /**
+     * Returns the configuration passed to the root resource.
+     * @returns The root resource configuration
+     *
+     * @example
+     * const config = runtime.getRootConfig<AppConfig>();
      */
-    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = DependencyMapType>(task: ITask<I, O, D> | string, ...args: I extends undefined | void ? [] : [I]) => Promise<O | undefined>;
+    getRootConfig: <Config = unknown>() => Config;
     /**
-     * Emit an event within the context of the run result.
-     * @param event - The event to emit.
-     * @param payload - The payload to emit.
+     * Returns the initialized value of the root resource.
+     *
+     * This is the value returned by the root resource's `init` function.
+     * The root must have been fully initialized before calling this.
+     *
+     * @returns The root resource's initialized value
+     * @throws RuntimeError if root hasn't been initialized yet
+     *
+     * @example
+     * const app = runtime.getRootValue<App>();
      */
-    emitEvent: <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P) => Promise<void>;
+    getRootValue: <Value = unknown>() => Value;
     /**
-     * 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.
+     * Extracts the resource ID from a resource definition or string.
+     * @internal
      */
-    getResourceValue: <Output extends Promise<any>>(resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
+    private getResourceId;
     /**
-     * Get the config of a resource from the run result.
-     * @param resource - The resource to get the config of.
-     * @returns The config passed for the resource.
+     * Disposes the runtime and all registered resources.
+     *
+     * Disposal executes in reverse initialization order:
+     * 1. All resource `dispose` methods are called
+     * 2. Event listeners are cleared
+     * 3. Async contexts are reset
+     *
+     * After disposal, any further operations will throw.
+     * Safe to call multiple times (subsequent calls return immediately).
+     *
+     * @returns Promise that resolves when disposal is complete
+     * @throws RuntimeError if called during bootstrap phase
+     *
+     * @example
+     * await runtime.dispose();
+     * // All resources cleaned up, runtime is now inactive
      */
-    getResourceConfig: <Config>(resource: string | IResource<Config, any, any, any, any>) => Config;
     dispose: () => Promise<void>;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import { IResource, RegisterableItems, ITag, AnyTask, ITaskMiddleware, IResourceMiddleware, TaggedTask, TaggedResource, AnyResource } from "../defs";
+import { IResource, RegisterableItems, ITag, AnyTask, TaggedTask, TaggedResource, AnyResource } from "../defs";
 import { EventManager } from "./EventManager";
 import { Logger } from "./Logger";
 import { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType } from "../types/storeTypes";
@@ -6,6 +6,8 @@ import { TaskRunner } from "./TaskRunner";
 import { OnUnhandledError } from "./UnhandledError";
 import { MiddlewareManager } from "./MiddlewareManager";
 import { RunnerMode } from "../types/runner";
+import { RunResult } from "./RunResult";
+import type { ITask } from "../types/task";
 export type { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType, };
 /**
  * Store class which is used to store all the resources, tasks, middleware and events.
@@ -22,6 +24,7 @@ export declare class Store {
     private taskRunner?;
     private middlewareManager;
     private readonly initializedResourceIds;
+    private preferInitOrderDisposal;
     mode: RunnerMode;
     constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError, mode?: RunnerMode);
     get tasks(): import("..").LockableMap<string, TaskStoreElementType>;
@@ -33,24 +36,31 @@ export declare class Store {
     get taskMiddlewares(): import("..").LockableMap<string, import("..").TaskMiddlewareStoreElementType>;
     get resourceMiddlewares(): import("..").LockableMap<string, import("..").ResourceMiddlewareStoreElementType>;
     get tags(): import("..").LockableMap<string, ITag<void, void, void>>;
-    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | import("..").ITask<any, any, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | import("..").IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]>>;
+    get overrides(): Map<string, import("..").IResourceMiddleware<any, void, void, any> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], import("..").IResourceMiddleware<any, void, void, any>[]> | ITask<any, Promise<unknown>, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | import("..").IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | import("..").ITaskMiddleware<any, void, void, any>>;
     get overrideRequests(): Set<{
         source: string;
         override: RegisterableItems;
     }>;
     getMiddlewareManager(): MiddlewareManager;
+    /**
+     * Checks whether a registered item is visible to a consumer id under the
+     * current exports visibility model.
+     */
+    isItemVisibleToConsumer(targetId: string, consumerId: string): boolean;
     get isLocked(): boolean;
     lock(): void;
     checkLock(): void;
     private registerGlobalComponents;
     setTaskRunner(taskRunner: TaskRunner): void;
+    setPreferInitOrderDisposal(prefer: boolean): void;
     private setupRootResource;
     validateDependencyGraph(): void;
     validateEventEmissionGraph(): void;
-    initializeStore(root: IResource<any, any, any, any, any>, config: unknown): void;
+    initializeStore(root: IResource<any, any, any, any, any>, config: unknown, runtimeResult: RunResult<unknown>): void;
     dispose(): Promise<void>;
     recordResourceInitialized(resourceId: string): void;
     private getResourcesInDisposeOrder;
+    private clearRuntimeStateAfterDispose;
     /**
      * Internal, avoid using this method directly.
      */
@@ -75,4 +85,11 @@ export declare class Store {
      */
     getResourcesWithTag<TTag extends ITag<any, any, any>>(tag: TTag): TaggedResource<TTag>[];
     getResourcesWithTag(tag: string): AnyResource[];
+    /**
+     * Returns all error ids declared across a task or resource and its full
+     * dependency chain: own throws, middleware throws (local + everywhere),
+     * resource dependency throws, and — for tasks — hook throws on events
+     * the task can emit. Deduplicated.
+     */
+    getAllThrows(target: ITask<any, any, any, any, any, any> | IResource<any, any, any, any>): readonly string[];
 }

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

@@ -5,6 +5,7 @@ import { Store } from "./Store";
 import { IErrorHelper } from "../types/error";
 import type { IAsyncContext } from "../types/asyncContext";
 import { LockableMap } from "../tools/LockableMap";
+import { VisibilityTracker } from "./VisibilityTracker";
 type StoringMode = "normal" | "override";
 export declare class StoreRegistry {
     protected readonly store: Store;
@@ -17,6 +18,7 @@ export declare class StoreRegistry {
     tags: LockableMap<string, ITag<void, void, void>>;
     asyncContexts: LockableMap<string, IAsyncContext<any>>;
     errors: LockableMap<string, IErrorHelper<any>>;
+    readonly visibilityTracker: VisibilityTracker;
     private validator;
     constructor(store: Store);
     getValidator(): StoreValidator;

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

@@ -4,5 +4,7 @@ export declare class StoreValidator {
     constructor(registry: StoreRegistry);
     checkIfIDExists(id: string): void | never;
     runSanityChecks(): void;
+    private getTaggableEntries;
+    private ensureTagIdsAreUniquePerDefinition;
     ensureAllTagsUsedAreRegistered(): void;
 }

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

@@ -4,11 +4,12 @@ import { Store } from "./Store";
 import { Logger } from "./Logger";
 import type { ExecutionJournal } from "../types/executionJournal";
 import type { TaskCallOptions } from "../types/utilities";
+type CachedTaskRunner = (input: unknown, journal?: ExecutionJournal) => Promise<unknown>;
 export declare class TaskRunner {
     protected readonly store: Store;
     protected readonly eventManager: EventManager;
     protected readonly logger: Logger;
-    protected readonly runnerStore: Map<string | symbol, (input: any, journal?: ExecutionJournal) => Promise<any>>;
+    protected readonly runnerStore: Map<string | symbol, CachedTaskRunner>;
     constructor(store: Store, eventManager: EventManager, logger: Logger);
     private readonly middlewareManager;
     /**
@@ -26,3 +27,4 @@ export declare class TaskRunner {
      */
     protected createRunnerWithMiddleware<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: TInput, parentJournal?: ExecutionJournal) => Promise<Awaited<TOutput>>;
 }
+export {};

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

@@ -0,0 +1,75 @@
+import { RegisterableItems } from "../defs";
+import { StoreRegistry } from "./StoreRegistry";
+/**
+ * Tracks which resource owns (registered) each item and which items
+ * are exported by resources that declare an exports list.
+ *
+ * Ownership is established during registration: when resource R calls
+ * `.register([item])`, item is "owned" by R.
+ *
+ * When R declares `.exports([subset])`, only those items are visible
+ * to items outside R's registration subtree.
+ */
+export declare class VisibilityTracker {
+    /**
+     * Maps item id → id of the resource that directly registered it.
+     * Items registered by the root resource have the root's id as owner.
+     */
+    private readonly ownership;
+    /**
+     * For each resource that declares exports: resource id → Set of
+     * exported item ids. Resources without `.exports()` are absent
+     * from this map (meaning "everything is public").
+     */
+    private readonly exportSets;
+    /**
+     * Maps resource id → set of all item ids in its registration subtree
+     * (including items registered by nested child resources).
+     */
+    private readonly subtrees;
+    /**
+     * Records ownership when a resource registers an item.
+     */
+    recordOwnership(ownerResourceId: string, item: RegisterableItems): void;
+    /**
+     * Records the export set for a resource that declares `.exports()`.
+     */
+    recordExports(resourceId: string, exports: Array<RegisterableItems>): void;
+    /**
+     * Checks whether `consumerId` can access `targetId`.
+     *
+     * An item is accessible if:
+     * 1. The target's owner has no exports list (everything is public), OR
+     * 2. The consumer is inside the same registration subtree as the target, OR
+     * 3. The target is in the owner resource's export set (transitively up).
+     */
+    isAccessible(targetId: string, consumerId: string): boolean;
+    private isAccessibleFromOwnerChain;
+    private isTargetAllowedByExports;
+    private isVisibleOutsideExportedResource;
+    /**
+     * Validates that all dependency references respect visibility boundaries.
+     * Called after registration is complete, before dependency computation.
+     */
+    validateVisibility(registry: StoreRegistry): void;
+    /**
+     * Checks dependencies declared by all dependency-bearing definitions.
+     */
+    private validateItemDependencies;
+    /**
+     * Validates that hook listeners only subscribe to visible events.
+     */
+    private validateHookEventVisibility;
+    /**
+     * Validates that middleware attachments are visible.
+     */
+    private validateMiddlewareVisibility;
+    /**
+     * Finds the first export set in the ownership chain that gates `targetId`.
+     */
+    private findGatingExportSet;
+    /** Exposes the ownership map for testing. */
+    getOwnership(): ReadonlyMap<string, string>;
+    /** Exposes the export sets for testing. */
+    getExportSets(): ReadonlyMap<string, ReadonlySet<string>>;
+}

package/dist/types/models/dependency-processor/DependencyExtractor.d.ts

@@ -0,0 +1,23 @@
+import { DependencyMapType, DependencyValuesType, IEvent, IEventEmitOptions, IResource, ITask, ResourceDependencyValuesType, TaskCallOptions } from "../../defs";
+import { EventManager } from "../EventManager";
+import { Logger } from "../Logger";
+import { Store } from "../Store";
+import { TaskRunner } from "../TaskRunner";
+import { ResourceStoreElementType } from "../../types/storeTypes";
+export declare class DependencyExtractor {
+    private readonly store;
+    private readonly eventManager;
+    private readonly taskRunner;
+    private readonly logger;
+    private readonly ensureResourceInitialized;
+    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger, ensureResourceInitialized: (resource: ResourceStoreElementType<any, any, any>) => Promise<void>);
+    wrapResourceDependencies<TD extends DependencyMapType>(deps: TD, extracted: DependencyValuesType<TD>, ownerResourceId: string): ResourceDependencyValuesType<TD>;
+    extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
+    extractDependency(object: unknown, source: string): Promise<any>;
+    extractEventDependency(object: IEvent<any>, source: string): (input: unknown, options?: IEventEmitOptions) => Promise<void | import("../..").IEventEmitReport>;
+    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown, options?: TaskCallOptions) => Promise<any>>;
+    extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
+    private makeTaskWithIntercept;
+    private makeOwnerAwareMiddlewareManager;
+    private getStoreTaskOrThrow;
+}

package/dist/types/models/dependency-processor/HookEventBuffer.d.ts

@@ -0,0 +1,15 @@
+import type { IEventEmission } from "../../defs";
+import { EventManager } from "../EventManager";
+import { Logger } from "../Logger";
+import { HookStoreElementType } from "../../types/storeTypes";
+export declare class HookEventBuffer {
+    private readonly eventManager;
+    private readonly logger;
+    private readonly runtimeEventCycleDetection;
+    private static readonly MAX_FLUSH_PASSES_WITHOUT_CYCLE_DETECTION;
+    readonly pendingHookEvents: Map<string, IEventEmission<any>[]>;
+    readonly drainingHookIds: Set<string>;
+    constructor(eventManager: EventManager, logger: Logger, runtimeEventCycleDetection: boolean);
+    enqueue(hookId: string, event: IEventEmission<any>): void;
+    flush(hookStoreElement: HookStoreElementType): Promise<void>;
+}

package/dist/types/models/dependency-processor/ResourceScheduler.d.ts

@@ -0,0 +1,10 @@
+import { ResourceStoreElementType } from "../../types/storeTypes";
+import { Store } from "../Store";
+export declare class ResourceScheduler {
+    private readonly store;
+    private readonly ensureResourceInitialized;
+    constructor(store: Store, ensureResourceInitialized: (resource: ResourceStoreElementType<any, any, any>) => Promise<void>);
+    collectStartupRequiredResourceIds(): Set<string>;
+    initializeUninitializedResourcesParallel(targetResourceIds?: ReadonlySet<string>): Promise<void>;
+    isResourceReadyForParallelInit(resource: ResourceStoreElementType<any, any, any>): boolean;
+}

package/dist/types/models/event/EmissionExecutor.d.ts

@@ -1,11 +1,12 @@
-import { IEventEmission } from "../../defs";
+import { EventEmissionFailureMode, IEventEmission, IEventEmitReport } from "../../defs";
 import { IListenerStorage } from "./types";
 interface ExecuteOptions {
     listeners: IListenerStorage[];
     event: IEventEmission<any>;
-    isPropagationStopped: () => boolean;
+    isPropagationStopped?: () => boolean;
+    failureMode: EventEmissionFailureMode;
 }
-export declare function executeSequentially({ listeners, event, isPropagationStopped, }: ExecuteOptions): Promise<void>;
-export declare function executeInParallel({ listeners, event, }: Omit<ExecuteOptions, "isPropagationStopped">): Promise<void>;
+export declare function executeSequentially({ listeners, event, isPropagationStopped, failureMode, }: ExecuteOptions): Promise<IEventEmitReport>;
+export declare function executeInParallel({ listeners, event, failureMode, }: Omit<ExecuteOptions, "isPropagationStopped">): Promise<IEventEmitReport>;
 export declare function shouldExecuteListener(listener: IListenerStorage, event: IEventEmission<any>): boolean;
 export {};

package/dist/types/models/event/ListenerRegistry.d.ts

@@ -15,6 +15,7 @@ export declare class ListenerRegistry {
     get globalListenersCacheValid(): boolean;
     addListener(eventId: string, newListener: IListenerStorage): void;
     addGlobalListener(newListener: IListenerStorage): void;
+    removeListenerById(id: string): void;
     getListenersForEmit(eventDefinition: IEvent<any>): IListenerStorage[];
     hasListeners(eventDefinition: IEvent<any>): boolean;
     /**
@@ -26,6 +27,7 @@ export declare class ListenerRegistry {
     private invalidateCache;
     private mergeSortedListeners;
     private insertListener;
+    private removeFromListeners;
 }
 export declare function createListener(newListener: Partial<IListenerStorage>): IListenerStorage;
 export {};

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

@@ -1,12 +1,10 @@
-export * from "./DependencyProcessor";
 export * from "./EventManager";
 export * from "./Logger";
 export * from "./Store";
 export * from "./TaskRunner";
-export * from "./ResourceInitializer";
 export * from "./MiddlewareManager";
 export { LogPrinter } from "./LogPrinter";
-export type { PrintableLog, ColorTheme, LogLevels as LogPrinterLevels, PrintStrategy as LogPrinterPrintStrategy, } from "./LogPrinter";
+export type { PrintableLog, PrintStrategy as LogPrinterPrintStrategy, } from "./LogPrinter";
 export * from "./Semaphore";
 export * from "./Queue";
 export * from "./UnhandledError";