@bluelibs/runner 5.1.0 → 5.2.1

package/dist/types/globals/resources/debug/hook.hook.d.ts

@@ -0,0 +1,30 @@
+export declare const hookInterceptorResource: import("../../..").IResource<void, Promise<void>, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../..").IResource<void, Promise<import("../../..").EventManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/debug/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./debug.resource";
+export * from "./debugConfig.resource";
+export * from "./types";
+export * from "./globalEvent.hook";
+export * from "./executionTracker.middleware";
+export * from "./debug.tag";

package/dist/types/globals/resources/debug/middleware.hook.d.ts

@@ -0,0 +1,30 @@
+export declare const middlewareInterceptorResource: import("../../..").IResource<void, Promise<void>, {
+    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
+        logResourceConfig: boolean;
+        logResourceValue: boolean;
+        logResourceBeforeRun: boolean;
+        logResourceAfterRun: boolean;
+        logTaskBeforeRun: boolean;
+        logTaskInput: boolean;
+        logTaskOutput: boolean;
+        logTaskAfterRun: boolean;
+        logMiddlewareBeforeRun: boolean;
+        logMiddlewareAfterRun: boolean;
+        logEventEmissionOnRun: boolean;
+        logEventEmissionInput: boolean;
+        logHookTriggered: boolean;
+        logHookCompleted: boolean;
+    }>, {}, any, {
+        title: string;
+        description: string;
+    }, import("../../..").ITag<{
+        metadata?: Record<string, any>;
+    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+    middlewareManager: import("../../..").IResource<void, Promise<import("../../..").MiddlewareManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("../../..").ITag<{
+    metadata?: Record<string, any>;
+}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

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

@@ -0,0 +1,25 @@
+import { ITaggable } from "../../../defs";
+export type DebugConfig = {
+    logResourceConfig: boolean;
+    logResourceValue: boolean;
+    logResourceBeforeRun: boolean;
+    logResourceAfterRun: boolean;
+    logTaskBeforeRun: boolean;
+    logTaskInput: boolean;
+    logTaskOutput: boolean;
+    logTaskAfterRun: boolean;
+    logMiddlewareBeforeRun: boolean;
+    logMiddlewareAfterRun: boolean;
+    logEventEmissionOnRun: boolean;
+    logEventEmissionInput: boolean;
+    logHookTriggered: boolean;
+    logHookCompleted: boolean;
+};
+export declare const allFalse: DebugConfig;
+export declare const levelNormal: DebugConfig;
+export declare const levelVerbose: DebugConfig;
+/**
+ * If you choose to specify your own config, all values will be set to false by default and extended by your config.
+ */
+export type DebugFriendlyConfig = "normal" | "verbose" | Partial<DebugConfig>;
+export declare const getConfig: (config: DebugFriendlyConfig, taggable?: ITaggable) => DebugConfig;

package/dist/types/globals/resources/debug/utils.d.ts

@@ -0,0 +1,2 @@
+import { ITaggable } from "../../../defs";
+export declare const hasSystemTag: (definition: ITaggable) => boolean;

package/dist/types/globals/resources/httpClientFactory.resource.d.ts

@@ -0,0 +1,28 @@
+import { type HttpClient } from "../../http-client";
+import type { HttpClientConfig } from "../../http-client";
+/**
+ * Factory for creating HTTP clients with automatic injection of:
+ * - serializer
+ * - error registry (from Store)
+ * - async contexts (from Store)
+ *
+ * Note: Node streaming clients are exposed via the Node entry only
+ * (see createHttpSmartClient/createHttpMixedClient in `@bluelibs/runner/node`).
+ * Keeping this universal factory browser-safe avoids dynamic imports.
+ */
+export interface HttpClientFactoryConfig {
+    baseUrl: string;
+    auth?: HttpClientConfig["auth"];
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    onRequest?: HttpClientConfig["onRequest"];
+}
+export type HttpClientFactory = (config: HttpClientFactoryConfig) => HttpClient;
+export declare const httpClientFactory: import("../..").IResource<void, Promise<HttpClientFactory>, {
+    serializer: import("../..").IResource<void, Promise<import("./tunnel/types").Serializer>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    store: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+}, any, {
+    title: string;
+    description: string;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export type { HttpClient };

package/dist/types/globals/resources/queue.resource.d.ts

@@ -0,0 +1,10 @@
+import { Queue } from "../../models/Queue";
+export declare const queueResource: import("../..").IResource<void, Promise<{
+    map: Map<string, Queue>;
+    run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+}>, {}, {
+    map: Map<string, Queue>;
+}, {
+    title: string;
+    description: string;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/resources/tunnel/error-utils.d.ts

@@ -0,0 +1 @@
+export declare function normalizeError(input: unknown): Error;

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

@@ -0,0 +1,19 @@
+import type { ITaskMiddleware } from "../../../defs";
+export type ValidationSide = "client" | "server" | "both";
+export interface ExecutionPlan {
+    clientMiddleware: string[];
+    serverMiddleware: string[];
+    validation: ValidationSide;
+}
+export interface PlanMeta {
+    plan?: ExecutionPlan;
+    headers?: Record<string, string>;
+    traceId?: string;
+    context?: unknown;
+}
+export declare function computeExecutionPlanFromWhitelist(whitelist: {
+    client?: Array<string | ITaskMiddleware<any, any, any, any>>;
+    server?: Array<string | ITaskMiddleware<any, any, any, any>>;
+}, opts?: {
+    defaultValidation?: ValidationSide;
+}): ExecutionPlan;

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

@@ -0,0 +1,48 @@
+import type { ITask, IEventEmission } from "../../../defs";
+export interface ProtocolErrorShape {
+    code: string;
+    message: string;
+    details?: unknown;
+    id?: string;
+    data?: unknown;
+}
+export interface ProtocolEnvelope<T = unknown> {
+    ok: boolean;
+    result?: T;
+    error?: ProtocolErrorShape;
+    meta?: {
+        protocolVersion?: string;
+        traceId?: string;
+        taskVersion?: string;
+    };
+}
+export interface TaskRequest {
+    id: string;
+    input?: unknown;
+    plan?: unknown;
+    context?: Record<string, unknown>;
+    traceId?: string;
+}
+export interface EventRequest {
+    id: string;
+    payload?: unknown;
+    returnPayload?: boolean;
+    context?: Record<string, unknown>;
+    traceId?: string;
+}
+export declare class TunnelError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    readonly id?: string;
+    readonly data?: unknown;
+    constructor(code: string, message: string, details?: unknown, extras?: {
+        id?: string;
+        data?: unknown;
+    });
+}
+export declare function toTunnelError(input: unknown, fallbackMessage?: string): TunnelError;
+export declare function assertOkEnvelope<T>(envelope: ProtocolEnvelope<T> | undefined, opts?: {
+    fallbackMessage?: string;
+}): T;
+export declare function runViaTunnel(runner: (task: ITask<any, any, any, any, any, any>, input?: unknown) => Promise<unknown>, task: ITask<any, any, any, any, any, any>, input?: unknown): Promise<unknown>;
+export declare function emitViaTunnel(runner: (emission: IEventEmission<any>) => Promise<unknown>, emission: IEventEmission<any>): Promise<void>;

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

@@ -0,0 +1,26 @@
+import type { ITaskMiddleware } from "../../../defs";
+export type TunnelPolicySide = "client" | "server";
+export type TunnelMiddlewareId = string | ITaskMiddleware<any, any, any, any>;
+export interface TunnelTaskMiddlewareSidePolicy {
+    /**
+     * Middleware ids/definitions allowed to run on this side when the task is tunneled.
+     * If omitted, defaults to allowing none (caller-side middleware is skipped by default).
+     */
+    middlewareAllowList?: TunnelMiddlewareId[];
+}
+export type TunnelTaskMiddlewarePolicySideConfig = TunnelTaskMiddlewareSidePolicy | TunnelMiddlewareId[];
+export interface TunnelTaskMiddlewarePolicyConfig {
+    /**
+     * Preferred configuration shape: explicit per-side allowlist.
+     */
+    client?: TunnelTaskMiddlewarePolicySideConfig;
+    server?: TunnelTaskMiddlewarePolicySideConfig;
+    /**
+     * Backwards-compatible configuration shape (previous): grouped allowlists.
+     */
+    middlewareAllowList?: {
+        client?: TunnelMiddlewareId[];
+        server?: TunnelMiddlewareId[];
+    };
+}
+export declare const tunnelPolicyTag: import("../../..").ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;

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

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

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

@@ -0,0 +1,48 @@
+import type { ITask, IEvent, IEventEmission } from "../../../defs";
+import type { IAsyncContext } from "../../../types/asyncContext";
+import type { IErrorHelper } from "../../../types/error";
+import type { SerializerLike } from "../../../serializer";
+export type { SerializerLike as Serializer } from "../../../serializer";
+export type TunnelMode = "client" | "server" | "both" | "none";
+export type TunnelTaskSelector = Array<string | ITask<any, any, any, any, any, any>> | ((task: ITask<any, any, any, any, any, any>) => boolean);
+export type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<any>) => boolean);
+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 interface TunnelRunner {
+    transport?: "http" | string;
+    mode?: TunnelMode;
+    tasks?: TunnelTaskSelector;
+    events?: TunnelEventSelector;
+    eventDeliveryMode?: EventDeliveryMode;
+    run?: TunnelTaskRunner;
+    emit?: (event: IEventEmission<any>) => Promise<any>;
+}
+export interface ExposureFetchAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface ExposureFetchConfig {
+    baseUrl: string;
+    auth?: ExposureFetchAuthConfig;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<unknown>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
+}
+export interface ExposureFetchClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+    /**
+     * Emits an event and returns the final payload as seen by the remote Runner.
+     * Requires server support; older servers will respond with `{ ok: true }`
+     * without `result`, in which case clients should throw.
+     */
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
+}

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

@@ -0,0 +1,23 @@
+import type { SerializerLike } from "../../serializer";
+import type { ExposureFetchClient } from "../../http-fetch-tunnel.resource";
+export interface HttpClientAuthConfig {
+    header?: string;
+    token: string;
+}
+export interface HttpCreateClientConfig {
+    url: string;
+    auth?: HttpClientAuthConfig;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export declare const tunnels: Readonly<{
+    http: Readonly<{
+        createClient(cfg: HttpCreateClientConfig): ExposureFetchClient;
+    }>;
+}>;
+export type { ExposureFetchClient };

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

@@ -0,0 +1,15 @@
+export * from "./resources/debug/types";
+export * from "./resources/tunnel/types";
+export * from "./debug";
+export type { CacheResourceConfig } from "./middleware/cache.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 { 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 { 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/http-client.d.ts

@@ -0,0 +1,26 @@
+import type { SerializerLike } from "./serializer";
+import type { IAsyncContext } from "./types/asyncContext";
+import type { IErrorHelper } from "./types/error";
+export interface HttpClientAuth {
+    header?: string;
+    token: string;
+}
+export interface HttpClientConfig {
+    baseUrl: string;
+    auth?: HttpClientAuth;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<unknown>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
+}
+export interface HttpClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
+}
+export declare function createHttpClient(cfg: HttpClientConfig): HttpClient;

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

@@ -0,0 +1,11 @@
+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/types/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @packageDocumentation
+ *
+ * # BlueLibs Runner
+ *
+ * A TypeScript-first dependency injection framework that combines functional programming
+ * with enterprise features. No decorators, no magic - just explicit, testable code.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { r, run } from "@bluelibs/runner";
+ *
+ * // Define a task (a function with superpowers)
+ * const greet = r.task("greet")
+ *   .run(async (name: string) => `Hello, ${name}!`)
+ *   .build();
+ *
+ * // Create and run your app
+ * const app = r.resource("app").register([greet]).build();
+ * const { runTask } = await run(app);
+ *
+ * console.log(await runTask(greet, "World")); // "Hello, World!"
+ * ```
+ *
+ * ## Core Concepts
+ *
+ * - **Tasks**: Functions with dependency injection, middleware, and validation
+ * - **Resources**: Singleton services with lifecycle management (init/dispose)
+ * - **Events**: Type-safe messages for decoupled communication
+ * - **Hooks**: Lightweight event handlers
+ * - **Middleware**: Cross-cutting concerns (auth, logging, caching)
+ *
+ * ## Learn More
+ *
+ * - [Documentation](https://github.com/bluelibs/runner/blob/main/README.md)
+ * - [Examples](https://github.com/bluelibs/runner/tree/main/examples)
+ * - [API Reference](https://bluelibs.github.io/runner/)
+ *
+ * @module @bluelibs/runner
+ */
+export * from "./public";
+export type * from "./defs";
+export type * from "./public-types";

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

@@ -0,0 +1,46 @@
+import { DependencyMapType, DependencyValuesType, ITask, IResource, IEvent, TaskCallOptions } 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";
+/**
+ * Resolves and caches computed dependencies for store items (resources, tasks, middleware, hooks).
+ */
+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);
+    /**
+     * Computes and caches dependencies for all registered store items.
+     */
+    computeAllDependencies(): Promise<void>;
+    private computeTaskDependencies;
+    initializeUninitializedResources(): Promise<void>;
+    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;
+    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, options?: TaskCallOptions) => Promise<any>>;
+    extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
+}

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

@@ -0,0 +1,115 @@
+import { DependencyValuesType, EventHandlerType, IEvent, IEventEmission } from "../defs";
+import { IHook } from "../types/hook";
+import { EventEmissionInterceptor, HookExecutionInterceptor, IEventHandlerOptions } from "./event/types";
+/**
+ * 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 emissionInterceptors;
+    private hookInterceptors;
+    private readonly registry;
+    private readonly cycleContext;
+    private readonly runtimeEventCycleDetection;
+    constructor(options?: {
+        runtimeEventCycleDetection?: 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>;
+    /**
+     * Emits an event and returns the final payload.
+     * The payload is taken from the deepest emission object that reached either:
+     * - the base listener executor, or
+     * - an interceptor that short-circuited the emission.
+     *
+     * This enables tunnel transports to return the final payload after local and/or remote delivery.
+     */
+    emitWithResult<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<TInput>;
+    private emitAndReturnEmission;
+    /**
+     * 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;
+    private assertPropagationMethodsUnchanged;
+    /**
+     * 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/ExecutionJournal.d.ts

@@ -0,0 +1,35 @@
+import { ExecutionJournal, JournalKey, JournalSetOptions } from "../types/executionJournal";
+/**
+ * Implementation of ExecutionJournal.
+ * Created per task execution and passed through the middleware chain.
+ */
+export declare class ExecutionJournalImpl implements ExecutionJournal {
+    private readonly store;
+    /**
+     * Store a value in the journal.
+     * Throws an error if the key already exists unless { override: true } is passed.
+     */
+    set<T>(key: JournalKey<T>, value: T, options?: JournalSetOptions): void;
+    get<T>(key: JournalKey<T>): T | undefined;
+    has<T>(key: JournalKey<T>): boolean;
+}
+/**
+ * Creates a typed journal key for use with ExecutionJournal.
+ *
+ * @example
+ * ```typescript
+ * const abortController = journal.createKey<AbortController>("timeout.abortController");
+ * journal.set(abortController, new AbortController());
+ * const ctrl = journal.get(abortController); // AbortController | undefined
+ * ```
+ */
+declare function createKey<T>(id: string): JournalKey<T>;
+export declare const journal: {
+    createKey: typeof createKey;
+    /**
+     * Creates a new empty ExecutionJournal.
+     * Useful when you need to pass a specific journal instance to `runTask` or nested calls.
+     */
+    create: () => ExecutionJournal;
+};
+export {};