@bluelibs/runner 4.9.0 → 5.0.0

package/dist/browser/index.d.mts

@@ -1,4 +1,4 @@
-export { EJSON } from '@bluelibs/ejson';
+import * as lru_cache from 'lru-cache';
 
 declare const CONTRACT: unique symbol;
 type CONTRACT = typeof CONTRACT;
@@ -79,7 +79,7 @@ interface IAsyncContextMeta extends IMeta {
 interface ITaggable {
     tags: TagType[];
 }
-interface ITagDefinition<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> {
+interface ITagDefinition<TConfig = void, _TEnforceInputContract = void, _TEnforceOutputContract = void> {
     id: string;
     meta?: ITagMeta;
     configSchema?: IValidationSchema<TConfig>;
@@ -110,7 +110,7 @@ interface ITag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContr
     [symbolFilePath]: string;
     [symbolTag]: true;
 }
-type ITagWithOptionalConfig<TValue, TEnforceInputContract, TEnforceOutputContract> = ITag<any, TEnforceInputContract, TEnforceOutputContract> & {
+type ITagWithOptionalConfig<_TValue, TEnforceInputContract, TEnforceOutputContract> = ITag<any, TEnforceInputContract, TEnforceOutputContract> & {
     readonly __configHasOnlyOptionalKeys: true;
 };
 interface ITagConfigured<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> extends ITag<TConfig, TEnforceInputContract, TEnforceOutputContract> {
@@ -152,9 +152,86 @@ declare const symbolFilePath: unique symbol;
 /** @internal Marks an async context definition */
 declare const symbolAsyncContext: unique symbol;
 
+interface IResourceMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
+    id: string;
+    /** Static or lazy dependency map. */
+    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
+    /**
+     * Optional validation schema for runtime config validation.
+     * When provided, middleware config will be validated when .with() is called.
+     */
+    configSchema?: IValidationSchema<TConfig>;
+    /**
+     * The middleware body, called with resource execution input.
+     */
+    run: (input: IResourceMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
+    meta?: IMiddlewareMeta;
+    tags?: TagType[];
+    everywhere?: boolean | ((resource: IResource<any, any, any, any, any>) => boolean);
+}
+interface IResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
+    [symbolResourceMiddleware]: true;
+    id: string;
+    dependencies: TDependencies | ((config: TConfig) => TDependencies);
+    /** Current configuration object (empty by default). */
+    config: TConfig;
+    /** Configure the middleware and return a marked, configured instance. */
+    with: (config: TConfig) => IResourceMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
+    [symbolFilePath]: string;
+    tags: TagType[];
+}
+interface IResourceMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
+    [symbolMiddlewareConfigured]: true;
+}
+interface IResourceMiddlewareExecutionInput<TResourceConfig = any, TResourceOutput = any> {
+    /** Resource hook */
+    resource: {
+        definition: IResource<TResourceConfig, any, any, any, any>;
+        config: TResourceConfig;
+    };
+    next: (resourceConfig?: TResourceConfig) => Promise<TResourceOutput>;
+}
+type ResourceMiddlewareAttachmentType = IResourceMiddleware<void, any, any, any> | IResourceMiddleware<{
+    [K in any]?: any;
+}, any, any, any> | IResourceMiddlewareConfigured<any, any, any, any>;
+
+type ErrorReference = string | IErrorHelper<any>;
+type ThrowsList = ReadonlyArray<ErrorReference>;
+interface IErrorDefinition<TData extends DefaultErrorType = DefaultErrorType> {
+    id: string;
+    serialize?: (data: TData) => string;
+    parse?: (data: string) => TData;
+    format?: (data: TData) => string;
+    /**
+     * Validate error data on throw(). If provided, data is parsed first.
+     */
+    dataSchema?: IValidationSchema<TData>;
+    meta?: IErrorMeta;
+}
+interface IErrorDefinitionFinal<TData extends DefaultErrorType> extends IErrorDefinition<TData> {
+    format: (data: TData) => string;
+}
+type DefaultErrorType = Record<string, unknown>;
+/**
+ * Runtime helper returned by defineError()/r.error().
+ * Contains helpers to throw typed errors and perform type-safe checks.
+ */
+interface IErrorHelper<TData extends DefaultErrorType = DefaultErrorType> {
+    /** Unique id for registration and DI */
+    id: string;
+    /** Throw a typed error with the given data */
+    throw(data: TData): never;
+    /** Type guard for checking if an unknown error is this error */
+    is(error: unknown): boolean;
+    /** Brand symbol for runtime detection */
+    [symbolError]: true;
+    /** Return an optional dependency wrapper for this error */
+    optional(): IOptionalDependency<IErrorHelper<TData>>;
+}
+
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsUnspecified<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : IsAny<T> extends true ? true : false;
-interface IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
+interface IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, _THooks = any, _TRegisterableItems = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
     /** Stable identifier. */
     id: string;
     /** Static or lazy dependency map. Receives `config` when provided. */
@@ -184,6 +261,16 @@ interface IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promi
      */
     dispose?: (this: any, value: TValue extends Promise<infer U> ? U : TValue, config: TConfig, dependencies: ResourceDependencyValuesType<TDependencies>, context: TContext) => Promise<void>;
     meta?: TMeta;
+    /**
+     * Declares which typed errors are part of this resource's contract.
+     *
+     * This is a declarative contract only:
+     * - It does not imply dependency injection
+     * - It does not enforce that only these errors can be thrown
+     *
+     * Use string ids or Error helpers.
+     */
+    throws?: ThrowsList;
     /**
      * Optional validation schema for runtime config validation.
      * When provided, resource config will be validated when .with() is called.
@@ -220,9 +307,17 @@ interface IResource<TConfig = void, TValue extends Promise<any> = Promise<any>,
     middleware: TMiddleware;
     [symbolFilePath]: string;
     [symbolResource]: true;
+    /** Normalized list of error ids declared via `throws`. */
+    throws?: readonly string[];
     /** Return an optional dependency wrapper for this resource. */
     optional: () => IOptionalDependency<IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>>;
     tags: TTags;
+    /**
+     * Create a new resource with a different id but the same definition.
+     * Useful for creating multiple instances of a "template" resource.
+     * The forked resource should be exported and used as a dependency.
+     */
+    fork(newId: string): IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
 }
 interface IResourceWithConfig<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends IResourceMiddleware<any, any, any, any>[] = IResourceMiddleware[]> {
     [symbolResourceWithConfig]: true;
@@ -234,55 +329,34 @@ interface IResourceWithConfig<TConfig = any, TValue extends Promise<any> = Promi
     config: TConfig;
 }
 
-interface ITaskDefinition<TInput = undefined, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
-    id: string;
-    /**
-     * Access other tasks/resources/events. Can be an object or a function when
-     * you need late or config‑dependent resolution.
-     */
-    dependencies?: TDependencies | (() => TDependencies);
-    /** Middleware applied around task execution. */
-    middleware?: TMiddleware;
-    /** Optional metadata used for docs, filtering and tooling. */
-    meta?: TMeta;
-    /**
-     * Optional validation schema for runtime input validation.
-     * When provided, task input will be validated before execution.
-     */
-    inputSchema?: IValidationSchema<TInput>;
-    /**
-     * Optional validation schema for the task result.
-     * When provided, the result will be validated immediately after the task's
-     * `run` resolves, without considering middleware.
-     */
-    resultSchema?: IValidationSchema<TOutput extends Promise<infer U> ? U : never>;
-    run: (input: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? [TInput] extends [undefined] ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TInput> : TInput, dependencies: DependencyValuesType<TDependencies>) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TOutput> : TOutput;
+/**
+ * Typed key used to store/retrieve values from an ExecutionJournal.
+ * The `id` is used as the storage slot.
+ */
+declare const journalKeyBrand: unique symbol;
+type JournalKey<T> = {
+    readonly id: string;
+    readonly [journalKeyBrand]?: (value: T) => T;
+};
+/**
+ * Options for setting values in the journal.
+ */
+interface JournalSetOptions {
     /**
-     * Tags applied to the task that might define its behvaiour or impact the systems.
+     * If true, allows overwriting an existing value.
+     * By default, attempting to set a key that already exists will throw an error.
      */
-    tags?: TTags;
+    override?: boolean;
 }
-interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> extends ITaskDefinition<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware> {
-    [symbolFilePath]: string;
-    [symbolTask]: true;
-    /** Present only for phantom tasks. */
-    [symbolPhantomTask]?: true;
-    /** Indicates if the task is tunneled through a tunnel client. */
-    isTunneled?: boolean;
-    /** Records which tunnel resource owns the task (exclusivity). */
-    [symbolTunneledBy]?: string;
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: TMiddleware;
-    /** Return an optional dependency wrapper for this task. */
-    optional: () => IOptionalDependency<ITask<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>>;
-    tags: TTags;
+/**
+ * Per-execution registry that allows middleware and tasks to share state.
+ * A new journal is created for each top-level task execution unless explicitly forwarded.
+ */
+interface ExecutionJournal {
+    set<T>(key: JournalKey<T>, value: T, options?: JournalSetOptions): void;
+    get<T>(key: JournalKey<T>): T | undefined;
+    has<T>(key: JournalKey<T>): boolean;
 }
-/** Narrowed type for phantom tasks (no-op run by default). */
-type IPhantomTask<TInput = any, TResolved = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITask<TInput, Promise<TResolved>, TDependencies, TMeta, TTags, TMiddleware> & {
-    [symbolPhantomTask]: true;
-};
 
 interface ITaskMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
     id: string;
@@ -305,7 +379,7 @@ interface ITaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceO
     [symbolTaskMiddleware]: true;
     [symbolFilePath]: string;
     id: string;
-    dependencies: TDependencies | (() => TDependencies);
+    dependencies: TDependencies | ((config: TConfig) => TDependencies);
     /** Current configuration object (empty by default). */
     config: TConfig;
     /** Configure the middleware and return a marked, configured instance. */
@@ -323,72 +397,76 @@ interface ITaskMiddlewareExecutionInput<TTaskInput = any, TTaskOutput = any> {
         input: TTaskInput;
     };
     next: (taskInput?: TTaskInput) => Promise<TTaskOutput>;
+    /** Per-execution registry for sharing state between middleware and task */
+    journal: ExecutionJournal;
 }
 type TaskMiddlewareAttachmentType = ITaskMiddleware<void, any, any, any> | ITaskMiddleware<{
     [K in any]?: any;
 }, any, any, any> | ITaskMiddlewareConfigured<any, any, any, any>;
 
-interface IResourceMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
+interface ITaskDefinition<TInput = undefined, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
     id: string;
-    /** Static or lazy dependency map. */
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
     /**
-     * Optional validation schema for runtime config validation.
-     * When provided, middleware config will be validated when .with() is called.
+     * Access other tasks/resources/events. Can be an object or a function when
+     * you need late or config‑dependent resolution.
      */
-    configSchema?: IValidationSchema<TConfig>;
+    dependencies?: TDependencies | (() => TDependencies);
+    /** Middleware applied around task execution. */
+    middleware?: TMiddleware;
+    /** Optional metadata used for docs, filtering and tooling. */
+    meta?: TMeta;
     /**
-     * The middleware body, called with resource execution input.
+     * Optional validation schema for runtime input validation.
+     * When provided, task input will be validated before execution.
      */
-    run: (input: IResourceMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-    tags?: TagType[];
-    everywhere?: boolean | ((resource: IResource<any, any, any, any, any>) => boolean);
+    inputSchema?: IValidationSchema<TInput>;
+    /**
+     * Optional validation schema for the task result.
+     * When provided, the result will be validated immediately after the task's
+     * `run` resolves, without considering middleware.
+     */
+    resultSchema?: IValidationSchema<TOutput extends Promise<infer U> ? U : never>;
+    /**
+     * Declares which typed errors are part of this task's contract.
+     *
+     * This is a declarative contract only:
+     * - It does not imply dependency injection
+     * - It does not enforce that only these errors can be thrown
+     *
+     * Use string ids or Error helpers.
+     */
+    throws?: ThrowsList;
+    run: (input: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? [TInput] extends [undefined] ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TInput> : TInput, dependencies: DependencyValuesType<TDependencies>, context?: {
+        journal: ExecutionJournal;
+    }) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TOutput> : TOutput;
+    /**
+     * Tags applied to the task that might define its behvaiour or impact the systems.
+     */
+    tags?: TTags;
 }
-interface IResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
-    [symbolResourceMiddleware]: true;
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    /** Current configuration object (empty by default). */
-    config: TConfig;
-    /** Configure the middleware and return a marked, configured instance. */
-    with: (config: TConfig) => IResourceMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
+interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> extends ITaskDefinition<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware> {
     [symbolFilePath]: string;
-    tags: TagType[];
-}
-interface IResourceMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-}
-interface IResourceMiddlewareExecutionInput<TResourceConfig = any, TResourceOutput = any> {
-    /** Resource hook */
-    resource: {
-        definition: IResource<TResourceConfig, any, any, any, any>;
-        config: TResourceConfig;
-    };
-    next: (resourceConfig?: TResourceConfig) => Promise<TResourceOutput>;
-}
-type ResourceMiddlewareAttachmentType = IResourceMiddleware<void, any, any, any> | IResourceMiddleware<{
-    [K in any]?: any;
-}, any, any, any> | IResourceMiddlewareConfigured<any, any, any, any>;
-
-type OnType = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
-interface IHookDefinition<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> {
-    id: string;
-    dependencies?: TDependencies | (() => TDependencies);
-    on: TOn;
-    /** Listener execution order. Lower numbers run first. */
-    order?: number;
-    meta?: TMeta;
-    run: (event: IEventEmission<TOn extends "*" ? any : TOn extends readonly IEventDefinition<any>[] ? CommonPayload<TOn> : ExtractEventPayload<TOn>>, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
-    tags?: TagType[];
-}
-interface IHook<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> extends IHookDefinition<TDependencies, TOn, TMeta> {
+    [symbolTask]: true;
+    /** Present only for phantom tasks. */
+    [symbolPhantomTask]?: true;
+    /** Indicates if the task is tunneled through a tunnel client. */
+    isTunneled?: boolean;
+    /** Records which tunnel resource owns the task (exclusivity). */
+    [symbolTunneledBy]?: string;
     id: string;
     dependencies: TDependencies | (() => TDependencies);
-    [symbolFilePath]: string;
-    [symbolHook]: true;
-    tags: TagType[];
+    computedDependencies?: DependencyValuesType<TDependencies>;
+    middleware: TMiddleware;
+    /** Normalized list of error ids declared via `throws`. */
+    throws?: readonly string[];
+    /** Return an optional dependency wrapper for this task. */
+    optional: () => IOptionalDependency<ITask<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>>;
+    tags: TTags;
 }
+/** Narrowed type for phantom tasks (no-op run by default). */
+type IPhantomTask<TInput = any, TResolved = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITask<TInput, Promise<TResolved>, TDependencies, TMeta, TTags, TMiddleware> & {
+    [symbolPhantomTask]: true;
+};
 
 type EventHandlerType<T = any> = (event: IEventEmission<T>) => any | Promise<any>;
 declare function onAnyOf<T extends readonly IEventDefinition<any>[]>(...defs: T): T;
@@ -466,41 +544,25 @@ interface IEventEmission<TPayload = any> {
     tags: TagType[];
 }
 
-declare const ERROR_TYPES_LOADED: true;
-interface IErrorDefinition<TData extends DefaultErrorType = DefaultErrorType> {
+type OnType = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
+interface IHookDefinition<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> {
     id: string;
-    serialize?: (data: TData) => string;
-    parse?: (data: string) => TData;
-    format?: (data: TData) => string;
-    /**
-     * Validate error data on throw(). If provided, data is parsed first.
-     */
-    dataSchema?: IValidationSchema<TData>;
-    meta?: IErrorMeta;
-}
-interface IErrorDefinitionFinal<TData extends DefaultErrorType> extends IErrorDefinition<TData> {
-    format: (data: TData) => string;
+    dependencies?: TDependencies | (() => TDependencies);
+    on: TOn;
+    /** Listener execution order. Lower numbers run first. */
+    order?: number;
+    meta?: TMeta;
+    run: (event: IEventEmission<TOn extends "*" ? any : TOn extends readonly IEventDefinition<any>[] ? CommonPayload<TOn> : ExtractEventPayload<TOn>>, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
+    tags?: TagType[];
 }
-type DefaultErrorType = Record<string, unknown>;
-/**
- * Runtime helper returned by defineError()/r.error().
- * Contains helpers to throw typed errors and perform type-safe checks.
- */
-interface IErrorHelper<TData extends DefaultErrorType = DefaultErrorType> {
-    /** Unique id for registration and DI */
+interface IHook<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> extends IHookDefinition<TDependencies, TOn, TMeta> {
     id: string;
-    /** Throw a typed error with the given data */
-    throw(data: TData): never;
-    /** Type guard for checking if an unknown error is this error */
-    is(error: unknown): boolean;
-    /** Brand symbol for runtime detection */
-    [symbolError]: true;
-    /** Return an optional dependency wrapper for this error */
-    optional(): IOptionalDependency<IErrorHelper<TData>>;
+    dependencies: TDependencies | (() => TDependencies);
+    [symbolFilePath]: string;
+    [symbolHook]: true;
+    tags: TagType[];
 }
 
-declare const ASYNC_CONTEXT_TYPES_LOADED: true;
-
 interface IAsyncContextDefinition<T> {
     id: string;
     serialize?(data: T): string;
@@ -588,20 +650,31 @@ interface IOptionalDependency<T> {
     /** Brand symbol for optional dependency */
     [symbolOptionalDependency]: true;
 }
-type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
-type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
+type ExtractTaskInput<T> = T extends ITask<infer I, any, infer _D> ? I : never;
+type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer _D> ? O : never;
 type ExtractResourceConfig<T> = T extends IResource<infer C, any, any> ? C : never;
-type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V extends Promise<infer U> ? U : V : never;
+type ExtractResourceValue<T> = T extends IResource<any, infer V, infer _D> ? V extends Promise<infer U> ? U : V : never;
 type ExtractEventPayload<T> = T extends IEventDefinition<infer P> ? P : T extends IEvent<infer P> ? P : never;
 type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
 type CommonPayload<T extends readonly IEventDefinition<any>[] | IEventDefinition<any>> = T extends readonly IEventDefinition<any>[] ? {
     [K in keyof ExtractEventPayload<T[number]>]: UnionToIntersection<ExtractEventPayload<T[number]> extends any ? ExtractEventPayload<T[number]>[K] : never>;
 } : ExtractEventPayload<T>;
+/**
+ * Options that can be passed when calling a task dependency.
+ * Allows forwarding the execution journal to nested task calls.
+ */
+interface TaskCallOptions {
+    /** Optional journal to forward to the nested task */
+    journal?: ExecutionJournal;
+}
 /**
  * Task dependencies transform into callable functions: call with the task input
- * and you receive the task output.
+ * and you receive the task output. Optionally accepts TaskCallOptions for journal forwarding.
  */
-type TaskDependency<I, O> = (...args: I extends null | void ? [] : [I]) => O;
+type TaskDependency<I, O> = I extends null | void ? {
+    (options?: TaskCallOptions): O;
+    (input?: I, options?: TaskCallOptions): O;
+} : (input: I, options?: TaskCallOptions) => O;
 /**
  * Resource dependencies resolve to the resource's value directly.
  */
@@ -714,6 +787,7 @@ declare class LogPrinter {
     private formatContext;
     private normalizeForJson;
     private static NO_COLORS;
+    private static readonly DEFAULT_WRITERS;
     private static writers;
     static setWriters(writers: Partial<{
         log: (msg: any) => void;
@@ -868,7 +942,7 @@ type RunOptions = {
      * When set, forces runtime cycle detection for event emissions. Disable if you're sure
      * you don't have event deadlocks to improve event emission performance.
      */
-    runtimeCycleDetection?: boolean;
+    runtimeEventCycleDetection?: boolean;
     /**
      * Specify in which mode to run "dev", "prod" or "test".
      * If inside Node this is automatically detected from the NODE_ENV environment variable if not provided.
@@ -888,6 +962,8 @@ interface ICacheInstance {
     set(key: string, value: any): void;
     get(key: string): any;
     clear(): void;
+    /** Optional presence check to disambiguate cached undefined values */
+    has?(key: string): boolean;
 }
 
 type ResourceStoreElementType<C = any, V extends Promise<any> = any, D extends DependencyMapType = {}, TContext = any> = {
@@ -939,13 +1015,12 @@ type EventStoreElementType = {
  * - Safe overrides and strong typing around config and register mechanics
  */
 
-declare const defs_ASYNC_CONTEXT_TYPES_LOADED: typeof ASYNC_CONTEXT_TYPES_LOADED;
 type defs_CommonPayload<T extends readonly IEventDefinition<any>[] | IEventDefinition<any>> = CommonPayload<T>;
 type defs_DefaultErrorType = DefaultErrorType;
 type defs_DependencyMapType = DependencyMapType;
 type defs_DependencyValueType<T> = DependencyValueType<T>;
 type defs_DependencyValuesType<T extends DependencyMapType> = DependencyValuesType<T>;
-declare const defs_ERROR_TYPES_LOADED: typeof ERROR_TYPES_LOADED;
+type defs_ErrorReference = ErrorReference;
 type defs_EventHandlerType<T = any> = EventHandlerType<T>;
 type defs_EventStoreElementType = EventStoreElementType;
 type defs_ExtractEventPayload<T> = ExtractEventPayload<T>;
@@ -973,7 +1048,7 @@ type defs_IMiddlewareMeta = IMiddlewareMeta;
 type defs_IOptionalDependency<T> = IOptionalDependency<T>;
 type defs_IPhantomTask<TInput = any, TResolved = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = IPhantomTask<TInput, TResolved, TDependencies, TMeta, TTags, TMiddleware>;
 type defs_IResource<TConfig = void, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> = IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
-type defs_IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> = IResourceDefinition<TConfig, TValue, TDependencies, TContext, THooks, TRegisterableItems, TMeta, TTags, TMiddleware>;
+type defs_IResourceDefinition<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = {}, TContext = any, _THooks = any, _TRegisterableItems = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> = IResourceDefinition<TConfig, TValue, TDependencies, TContext, _THooks, _TRegisterableItems, TMeta, TTags, TMiddleware>;
 type defs_IResourceMeta = IResourceMeta;
 type defs_IResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
 type defs_IResourceMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = IResourceMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
@@ -982,7 +1057,7 @@ type defs_IResourceMiddlewareExecutionInput<TResourceConfig = any, TResourceOutp
 type defs_IResourceWithConfig<TConfig = any, TValue extends Promise<any> = Promise<any>, TDependencies extends DependencyMapType = any, TContext = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends IResourceMiddleware<any, any, any, any>[] = IResourceMiddleware[]> = IResourceWithConfig<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
 type defs_ITag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> = ITag<TConfig, TEnforceInputContract, TEnforceOutputContract>;
 type defs_ITagConfigured<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> = ITagConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract>;
-type defs_ITagDefinition<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> = ITagDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract>;
+type defs_ITagDefinition<TConfig = void, _TEnforceInputContract = void, _TEnforceOutputContract = void> = ITagDefinition<TConfig, _TEnforceInputContract, _TEnforceOutputContract>;
 type defs_ITagMeta = ITagMeta;
 type defs_ITaggable = ITaggable;
 type defs_ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITask<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>;
@@ -1006,11 +1081,13 @@ type defs_RunOptions = RunOptions;
 type defs_RunnerMode = RunnerMode;
 declare const defs_RunnerMode: typeof RunnerMode;
 type defs_TagType = TagType;
+type defs_TaskCallOptions = TaskCallOptions;
 type defs_TaskDependencyWithIntercept<TInput, TOutput> = TaskDependencyWithIntercept<TInput, TOutput>;
 type defs_TaskLocalInterceptor<TInput, TOutput> = TaskLocalInterceptor<TInput, TOutput>;
 type defs_TaskMiddlewareAttachmentType = TaskMiddlewareAttachmentType;
 type defs_TaskMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = TaskMiddlewareStoreElementType<TDeps>;
 type defs_TaskStoreElementType<Input = any, Output extends Promise<any> = any, D extends DependencyMapType = any> = TaskStoreElementType<Input, Output, D>;
+type defs_ThrowsList = ThrowsList;
 type defs_UnionToIntersection<U> = UnionToIntersection<U>;
 declare const defs_isOneOf: typeof isOneOf;
 declare const defs_onAnyOf: typeof onAnyOf;
@@ -1032,7 +1109,7 @@ declare const defs_symbolTask: typeof symbolTask;
 declare const defs_symbolTaskMiddleware: typeof symbolTaskMiddleware;
 declare const defs_symbolTunneledBy: typeof symbolTunneledBy;
 declare namespace defs {
-  export { defs_ASYNC_CONTEXT_TYPES_LOADED as ASYNC_CONTEXT_TYPES_LOADED, type defs_CommonPayload as CommonPayload, type defs_DefaultErrorType as DefaultErrorType, type defs_DependencyMapType as DependencyMapType, type defs_DependencyValueType as DependencyValueType, type defs_DependencyValuesType as DependencyValuesType, defs_ERROR_TYPES_LOADED as ERROR_TYPES_LOADED, type defs_EventHandlerType as EventHandlerType, type defs_EventStoreElementType as EventStoreElementType, type defs_ExtractEventPayload as ExtractEventPayload, type defs_ExtractResourceConfig as ExtractResourceConfig, type defs_ExtractResourceValue as ExtractResourceValue, type defs_ExtractTaskInput as ExtractTaskInput, type defs_ExtractTaskOutput as ExtractTaskOutput, type defs_HookStoreElementType as HookStoreElementType, type defs_IAsyncContext as IAsyncContext, type defs_IAsyncContextDefinition as IAsyncContextDefinition, type defs_IAsyncContextMeta as IAsyncContextMeta, type defs_ICacheInstance as ICacheInstance, type defs_IErrorDefinition as IErrorDefinition, type defs_IErrorDefinitionFinal as IErrorDefinitionFinal, type defs_IErrorHelper as IErrorHelper, type defs_IErrorMeta as IErrorMeta, type defs_IEvent as IEvent, type defs_IEventDefinition as IEventDefinition, type defs_IEventEmission as IEventEmission, type defs_IEventMeta as IEventMeta, type defs_IHook as IHook, type defs_IHookDefinition as IHookDefinition, type defs_IMeta as IMeta, type defs_IMiddlewareMeta as IMiddlewareMeta, type defs_IOptionalDependency as IOptionalDependency, type defs_IPhantomTask as IPhantomTask, type defs_IResource as IResource, type defs_IResourceDefinition as IResourceDefinition, type defs_IResourceMeta as IResourceMeta, type defs_IResourceMiddleware as IResourceMiddleware, type defs_IResourceMiddlewareConfigured as IResourceMiddlewareConfigured, type defs_IResourceMiddlewareDefinition as IResourceMiddlewareDefinition, type defs_IResourceMiddlewareExecutionInput as IResourceMiddlewareExecutionInput, type defs_IResourceWithConfig as IResourceWithConfig, type defs_ITag as ITag, type defs_ITagConfigured as ITagConfigured, type defs_ITagDefinition as ITagDefinition, type defs_ITagMeta as ITagMeta, type defs_ITaggable as ITaggable, type defs_ITask as ITask, type defs_ITaskDefinition as ITaskDefinition, type defs_ITaskMeta as ITaskMeta, type defs_ITaskMiddleware as ITaskMiddleware, type defs_ITaskMiddlewareConfigured as ITaskMiddlewareConfigured, type defs_ITaskMiddlewareDefinition as ITaskMiddlewareDefinition, type defs_ITaskMiddlewareExecutionInput as ITaskMiddlewareExecutionInput, type defs_IValidationSchema as IValidationSchema, type defs_OverridableElements as OverridableElements, type defs_RegisterableItems as RegisterableItems, type defs_RequiredKeys as RequiredKeys, type defs_ResourceDependencyValueType as ResourceDependencyValueType, type defs_ResourceDependencyValuesType as ResourceDependencyValuesType, type defs_ResourceInitFn as ResourceInitFn, type defs_ResourceMiddlewareAttachmentType as ResourceMiddlewareAttachmentType, type defs_ResourceMiddlewareStoreElementType as ResourceMiddlewareStoreElementType, type defs_ResourceStoreElementType as ResourceStoreElementType, type defs_RunOptions as RunOptions, defs_RunnerMode as RunnerMode, type defs_TagType as TagType, type defs_TaskDependencyWithIntercept as TaskDependencyWithIntercept, type defs_TaskLocalInterceptor as TaskLocalInterceptor, type defs_TaskMiddlewareAttachmentType as TaskMiddlewareAttachmentType, type defs_TaskMiddlewareStoreElementType as TaskMiddlewareStoreElementType, type defs_TaskStoreElementType as TaskStoreElementType, type defs_UnionToIntersection as UnionToIntersection, defs_isOneOf as isOneOf, defs_onAnyOf as onAnyOf, defs_symbolAsyncContext as symbolAsyncContext, defs_symbolError as symbolError, defs_symbolEvent as symbolEvent, defs_symbolFilePath as symbolFilePath, defs_symbolHook as symbolHook, defs_symbolMiddleware as symbolMiddleware, defs_symbolMiddlewareConfigured as symbolMiddlewareConfigured, defs_symbolOptionalDependency as symbolOptionalDependency, defs_symbolPhantomTask as symbolPhantomTask, defs_symbolResource as symbolResource, defs_symbolResourceMiddleware as symbolResourceMiddleware, defs_symbolResourceWithConfig as symbolResourceWithConfig, defs_symbolTag as symbolTag, defs_symbolTagConfigured as symbolTagConfigured, defs_symbolTask as symbolTask, defs_symbolTaskMiddleware as symbolTaskMiddleware, defs_symbolTunneledBy as symbolTunneledBy };
+  export { type defs_CommonPayload as CommonPayload, type defs_DefaultErrorType as DefaultErrorType, type defs_DependencyMapType as DependencyMapType, type defs_DependencyValueType as DependencyValueType, type defs_DependencyValuesType as DependencyValuesType, type defs_ErrorReference as ErrorReference, type defs_EventHandlerType as EventHandlerType, type defs_EventStoreElementType as EventStoreElementType, type defs_ExtractEventPayload as ExtractEventPayload, type defs_ExtractResourceConfig as ExtractResourceConfig, type defs_ExtractResourceValue as ExtractResourceValue, type defs_ExtractTaskInput as ExtractTaskInput, type defs_ExtractTaskOutput as ExtractTaskOutput, type defs_HookStoreElementType as HookStoreElementType, type defs_IAsyncContext as IAsyncContext, type defs_IAsyncContextDefinition as IAsyncContextDefinition, type defs_IAsyncContextMeta as IAsyncContextMeta, type defs_ICacheInstance as ICacheInstance, type defs_IErrorDefinition as IErrorDefinition, type defs_IErrorDefinitionFinal as IErrorDefinitionFinal, type defs_IErrorHelper as IErrorHelper, type defs_IErrorMeta as IErrorMeta, type defs_IEvent as IEvent, type defs_IEventDefinition as IEventDefinition, type defs_IEventEmission as IEventEmission, type defs_IEventMeta as IEventMeta, type defs_IHook as IHook, type defs_IHookDefinition as IHookDefinition, type defs_IMeta as IMeta, type defs_IMiddlewareMeta as IMiddlewareMeta, type defs_IOptionalDependency as IOptionalDependency, type defs_IPhantomTask as IPhantomTask, type defs_IResource as IResource, type defs_IResourceDefinition as IResourceDefinition, type defs_IResourceMeta as IResourceMeta, type defs_IResourceMiddleware as IResourceMiddleware, type defs_IResourceMiddlewareConfigured as IResourceMiddlewareConfigured, type defs_IResourceMiddlewareDefinition as IResourceMiddlewareDefinition, type defs_IResourceMiddlewareExecutionInput as IResourceMiddlewareExecutionInput, type defs_IResourceWithConfig as IResourceWithConfig, type defs_ITag as ITag, type defs_ITagConfigured as ITagConfigured, type defs_ITagDefinition as ITagDefinition, type defs_ITagMeta as ITagMeta, type defs_ITaggable as ITaggable, type defs_ITask as ITask, type defs_ITaskDefinition as ITaskDefinition, type defs_ITaskMeta as ITaskMeta, type defs_ITaskMiddleware as ITaskMiddleware, type defs_ITaskMiddlewareConfigured as ITaskMiddlewareConfigured, type defs_ITaskMiddlewareDefinition as ITaskMiddlewareDefinition, type defs_ITaskMiddlewareExecutionInput as ITaskMiddlewareExecutionInput, type defs_IValidationSchema as IValidationSchema, type defs_OverridableElements as OverridableElements, type defs_RegisterableItems as RegisterableItems, type defs_RequiredKeys as RequiredKeys, type defs_ResourceDependencyValueType as ResourceDependencyValueType, type defs_ResourceDependencyValuesType as ResourceDependencyValuesType, type defs_ResourceInitFn as ResourceInitFn, type defs_ResourceMiddlewareAttachmentType as ResourceMiddlewareAttachmentType, type defs_ResourceMiddlewareStoreElementType as ResourceMiddlewareStoreElementType, type defs_ResourceStoreElementType as ResourceStoreElementType, type defs_RunOptions as RunOptions, defs_RunnerMode as RunnerMode, type defs_TagType as TagType, type defs_TaskCallOptions as TaskCallOptions, type defs_TaskDependencyWithIntercept as TaskDependencyWithIntercept, type defs_TaskLocalInterceptor as TaskLocalInterceptor, type defs_TaskMiddlewareAttachmentType as TaskMiddlewareAttachmentType, type defs_TaskMiddlewareStoreElementType as TaskMiddlewareStoreElementType, type defs_TaskStoreElementType as TaskStoreElementType, type defs_ThrowsList as ThrowsList, type defs_UnionToIntersection as UnionToIntersection, defs_isOneOf as isOneOf, defs_onAnyOf as onAnyOf, defs_symbolAsyncContext as symbolAsyncContext, defs_symbolError as symbolError, defs_symbolEvent as symbolEvent, defs_symbolFilePath as symbolFilePath, defs_symbolHook as symbolHook, defs_symbolMiddleware as symbolMiddleware, defs_symbolMiddlewareConfigured as symbolMiddlewareConfigured, defs_symbolOptionalDependency as symbolOptionalDependency, defs_symbolPhantomTask as symbolPhantomTask, defs_symbolResource as symbolResource, defs_symbolResourceMiddleware as symbolResourceMiddleware, defs_symbolResourceWithConfig as symbolResourceWithConfig, defs_symbolTag as symbolTag, defs_symbolTagConfigured as symbolTagConfigured, defs_symbolTask as symbolTask, defs_symbolTaskMiddleware as symbolTaskMiddleware, defs_symbolTunneledBy as symbolTunneledBy };
 }
 
 interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
@@ -1052,7 +1129,7 @@ interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends
     everywhere(flag: boolean | ((task: ITask<any, any, any, any>) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
     build(): ITaskMiddleware<C, In, Out, D>;
 }
-declare function taskMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+
 interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
@@ -1070,35 +1147,29 @@ interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void, D exte
     everywhere(flag: boolean | ((resource: IResource<any, any, any, any, any>) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
     build(): IResourceMiddleware<C, In, Out, D>;
 }
-declare function resourceMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
 
-declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
-    readonly id: string;
-    readonly data: TData;
-    constructor(id: string, message: string, data: TData);
-}
-declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorType> implements IErrorHelper<TData> {
-    private readonly definition;
-    [symbolError]: true;
-    constructor(definition: IErrorDefinitionFinal<TData>);
-    get id(): string;
-    throw(data: TData): never;
-    is(error: unknown): error is RunnerError<TData>;
-    optional(): {
-        readonly inner: IErrorHelper<TData>;
-        readonly [symbolOptionalDependency]: true;
-    };
-}
+/**
+ * Entry point for creating a task middleware builder.
+ */
+declare function taskMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+/**
+ * Entry point for creating a resource middleware builder.
+ */
+declare function resourceMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
 
 interface ErrorFluentBuilder<TData extends DefaultErrorType = DefaultErrorType> {
     id: string;
     serialize(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
     parse(fn: (raw: string) => TData): ErrorFluentBuilder<TData>;
     dataSchema(schema: IValidationSchema<TData>): ErrorFluentBuilder<TData>;
-    build(): ErrorHelper<TData>;
+    build(): IErrorHelper<TData>;
     format(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
     meta<TNewMeta extends IErrorMeta>(m: TNewMeta): ErrorFluentBuilder<TData>;
 }
+
+/**
+ * Entry point for creating an error builder.
+ */
 declare function errorBuilder<TData extends DefaultErrorType = DefaultErrorType>(id: string): ErrorFluentBuilder<TData>;
 
 interface AsyncContextFluentBuilder<T = unknown> {
@@ -1109,6 +1180,10 @@ interface AsyncContextFluentBuilder<T = unknown> {
     meta<TNewMeta extends IAsyncContextMeta>(m: TNewMeta): AsyncContextFluentBuilder<T>;
     build(): IAsyncContext<T>;
 }
+
+/**
+ * Entry point for creating an async context builder.
+ */
 declare function asyncContextBuilder<T = unknown>(id: string): AsyncContextFluentBuilder<T>;
 
 interface TagFluentBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void> {
@@ -1118,11 +1193,19 @@ interface TagFluentBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void
     config<TNewConfig>(config: TNewConfig): TagFluentBuilder<TNewConfig, TEnforceIn, TEnforceOut>;
     build(): ITag<TConfig, TEnforceIn, TEnforceOut>;
 }
+
+/**
+ * Entry point for creating a tag builder.
+ */
 declare function tagBuilder<TConfig = void, TEnforceIn = void, TEnforceOut = void>(id: string): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
 
-interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] = any, TMeta extends ITaskMeta = ITaskMeta> {
+/** Valid event targets for hook's .on() method */
+type ValidOnTarget = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
+/** Resolved TOn when valid, or `any` when undefined (build will throw at runtime) */
+type ResolvedOn<TOn> = TOn extends ValidOnTarget ? TOn : any;
+interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn extends ValidOnTarget | undefined = undefined, TMeta extends ITaskMeta = ITaskMeta> {
     id: string;
-    on<TNewOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[]>(on: TNewOn): HookFluentBuilder<TDeps, TNewOn, TMeta>;
+    on<TNewOn extends ValidOnTarget>(on: TNewOn): HookFluentBuilder<TDeps, TNewOn, TMeta>;
     order(order: number): HookFluentBuilder<TDeps, TOn, TMeta>;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
         override?: false;
@@ -1134,10 +1217,20 @@ interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn extends "*
         override?: boolean;
     }): HookFluentBuilder<TDeps, TOn, TMeta>;
     meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookFluentBuilder<TDeps, TOn, TNewMeta>;
-    run(fn: IHookDefinition<TDeps, TOn, TMeta>["run"]): HookFluentBuilder<TDeps, TOn, TMeta>;
-    build(): IHook<TDeps, TOn, TMeta>;
+    /** Set the hook's run handler. Required before build(). */
+    run(fn: IHookDefinition<TDeps, ResolvedOn<TOn>, TMeta>["run"]): HookFluentBuilder<TDeps, TOn, TMeta>;
+    /**
+     * Build the hook definition. Requires .on() and .run() to be called first.
+     * @throws {Error} if on or run are not set
+     */
+    build(): IHook<TDeps, ResolvedOn<TOn>, TMeta>;
 }
-declare function hookBuilder(id: string): HookFluentBuilder<{}, any, ITaskMeta>;
+
+/**
+ * Entry point for creating a hook builder.
+ * Requires calling .on() and .run() before .build().
+ */
+declare function hookBuilder(id: string): HookFluentBuilder<{}, undefined, ITaskMeta>;
 
 interface EventFluentBuilder<TPayload = void> {
     id: string;
@@ -1156,69 +1249,98 @@ interface EventFluentBuilder<TPayload = void> {
     parallel(enabled?: boolean): EventFluentBuilder<TPayload>;
     build(): IEvent<TPayload>;
 }
-declare function eventBuilder(id: string): EventFluentBuilder<void>;
 
-interface PhantomTaskFluentBuilder<TInput = undefined, TResolved = any, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+/**
+ * Entry point for creating an event builder.
+ */
+declare function eventBuilder<TPayload = void>(id: string): EventFluentBuilder<TPayload>;
+
+type ShouldReplaceInput<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : 0 extends 1 & T ? true : false;
+type ResolveInput<TExisting, TProposed> = ShouldReplaceInput<TExisting> extends true ? TProposed : TExisting;
+
+/**
+ * Fluent builder interface for constructing tasks.
+ */
+interface TaskFluentBuilder<TInput = undefined, TOutput extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
         override?: false;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
         override: true;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TNewDeps, TMeta, TTags, TMiddleware>;
+    }): TaskFluentBuilder<TInput, TOutput, TNewDeps, TMeta, TTags, TMiddleware>;
     middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
         override?: boolean;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TNewMw>;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TNewMw>;
     tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
         override?: false;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, [
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, [
         ...TTags,
         ...TNewTags
     ], TMiddleware>;
     tags<TNewTags extends TagType[]>(t: TNewTags, options: {
         override: true;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TNewTags, TMiddleware>;
-    inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): PhantomTaskFluentBuilder<TNewInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
-    resultSchema<TNewResolved>(schema: IValidationSchema<TNewResolved>): PhantomTaskFluentBuilder<TInput, TNewResolved, TDeps, TMeta, TTags, TMiddleware>;
-    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TNewMeta, TTags, TMiddleware>;
-    build(): IPhantomTask<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TNewTags, TMiddleware>;
+    inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): TaskFluentBuilder<TNewInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+    resultSchema<TResolved>(schema: IValidationSchema<TResolved>): TaskFluentBuilder<TInput, Promise<TResolved>, TDeps, TMeta, TTags, TMiddleware>;
+    run<TNewInput = TInput, TNewOutput extends Promise<any> = TOutput>(fn: NonNullable<ITaskDefinition<ResolveInput<TInput, TNewInput>, TNewOutput, TDeps, TMeta, TTags, TMiddleware>["run"]>): TaskFluentBuilder<ResolveInput<TInput, TNewInput>, TNewOutput, TDeps, TMeta, TTags, TMiddleware>;
+    throws(list: ThrowsList): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): TaskFluentBuilder<TInput, TOutput, TDeps, TNewMeta, TTags, TMiddleware>;
+    build(): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
 }
 
-type ShouldReplaceInput<T> = [T] extends [undefined] ? true : [T] extends [void] ? true : (0 extends 1 & T ? true : false);
-type ResolveInput<TExisting, TProposed> = ShouldReplaceInput<TExisting> extends true ? TProposed : TExisting;
-interface TaskFluentBuilder<TInput = undefined, TOutput extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
+/**
+ * Fluent builder interface for constructing phantom tasks.
+ */
+interface PhantomTaskFluentBuilder<TInput = undefined, TResolved = any, TDeps extends DependencyMapType = {}, TMeta extends ITaskMeta = ITaskMeta, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
         override?: false;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
         override: true;
-    }): TaskFluentBuilder<TInput, TOutput, TNewDeps, TMeta, TTags, TMiddleware>;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TNewDeps, TMeta, TTags, TMiddleware>;
     middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
         override?: boolean;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TNewMw>;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TNewMw>;
     tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
         override?: false;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, [
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, [
         ...TTags,
         ...TNewTags
     ], TMiddleware>;
     tags<TNewTags extends TagType[]>(t: TNewTags, options: {
         override: true;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TNewTags, TMiddleware>;
-    inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): TaskFluentBuilder<TNewInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
-    resultSchema<TResolved>(schema: IValidationSchema<TResolved>): TaskFluentBuilder<TInput, Promise<TResolved>, TDeps, TMeta, TTags, TMiddleware>;
-    run<TNewInput = TInput, TNewOutput extends Promise<any> = TOutput>(fn: NonNullable<ITaskDefinition<ResolveInput<TInput, TNewInput>, TNewOutput, TDeps, TMeta, TTags, TMiddleware>["run"]>): TaskFluentBuilder<ResolveInput<TInput, TNewInput>, TNewOutput, TDeps, TMeta, TTags, TMiddleware>;
-    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): TaskFluentBuilder<TInput, TOutput, TDeps, TNewMeta, TTags, TMiddleware>;
-    build(): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TNewTags, TMiddleware>;
+    inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): PhantomTaskFluentBuilder<TNewInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+    resultSchema<TNewResolved>(schema: IValidationSchema<TNewResolved>): PhantomTaskFluentBuilder<TInput, TNewResolved, TDeps, TMeta, TTags, TMiddleware>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TNewMeta, TTags, TMiddleware>;
+    throws(list: ThrowsList): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
+    build(): IPhantomTask<TInput, TResolved, TDeps, TMeta, TTags, TMiddleware>;
 }
+
+/**
+ * Entry point for creating a phantom task builder.
+ */
+declare function phantomTaskBuilder<TInput = undefined, TResolved = any>(id: string): PhantomTaskFluentBuilder<TInput, TResolved, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
 interface TaskBuilderWithPhantom {
     (id: string): TaskFluentBuilder<undefined, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
-    phantom: <TInput = undefined, TResolved = any>(id: string) => PhantomTaskFluentBuilder<TInput, TResolved, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+    phantom: typeof phantomTaskBuilder;
 }
 
+/**
+ * Helper type to determine if config should be replaced.
+ */
 type ShouldReplaceConfig<T> = [T] extends [void] ? true : [T] extends [undefined] ? true : false;
+/**
+ * Resolves the config type - uses proposed if existing is void/undefined.
+ */
 type ResolveConfig<TExisting, TProposed> = ShouldReplaceConfig<TExisting> extends true ? TProposed : TExisting;
+
+/**
+ * Fluent builder interface for constructing resources.
+ * Each method returns a new builder with updated type parameters.
+ */
 interface ResourceFluentBuilder<TConfig = void, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TContext = any, TMeta extends IResourceMeta = IResourceMeta, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: TConfig) => TNewDeps), options?: {
@@ -1248,19 +1370,220 @@ interface ResourceFluentBuilder<TConfig = void, TValue extends Promise<any> = Pr
     init<TNewConfig = TConfig, TNewValue extends Promise<any> = TValue>(fn: ResourceInitFn<ResolveConfig<TConfig, TNewConfig>, TNewValue, TDeps, TContext, TMeta, TTags, TMiddleware>): ResourceFluentBuilder<ResolveConfig<TConfig, TNewConfig>, TNewValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
     dispose(fn: NonNullable<IResourceDefinition<TConfig, TValue, TDeps, TContext, any, any, TMeta, TTags, TMiddleware>["dispose"]>): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
     meta<TNewMeta extends IResourceMeta>(m: TNewMeta): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TNewMeta, TTags, TMiddleware>;
+    throws(list: ThrowsList): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
     overrides(o: Array<OverridableElements>, options?: {
         override?: boolean;
     }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
     build(): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
 }
-declare function resourceBuilder<TConfig = void>(id: string): ResourceFluentBuilder<TConfig, Promise<any>, {}, any, IResourceMeta, TagType[], ResourceMiddlewareAttachmentType[]>;
-
-interface Serializer {
+
+/**
+ * Creates a new resource builder with the given id.
+ * Overload allows callers to seed the config type at the entry point for convenience.
+ */
+declare function resourceBuilder<TConfig = void>(id: string): ResourceFluentBuilder<TConfig, Promise<any>, {}, any, IResourceMeta, TagType[], ResourceMiddlewareAttachmentType[]>;
+
+/**
+ * Type definitions for the Serializer class
+ */
+/**
+ * Definition for a custom type that can be serialized/deserialized
+ */
+interface TypeDefinition<TInstance = unknown, TSerialized = unknown> {
+    /** Unique identifier for the type */
+    id: string;
+    /** Predicate function to check if an object matches this type */
+    is: (obj: unknown) => obj is TInstance;
+    /** Function to serialize the object */
+    serialize: (obj: TInstance) => TSerialized;
+    /** Function to deserialize the data back to the original object */
+    deserialize: (data: TSerialized) => TInstance;
+    /** Optional factory used to create a placeholder during deserialization */
+    create?: () => TInstance;
+    /** Serialization strategy: 'value' (inline, no identity) or 'ref' (graph node, identity preserved). Default: 'ref' */
+    strategy?: "value" | "ref";
+}
+/** Reference to another object in the serialization */
+interface ObjectReference {
+    /** Reference to object ID */
+    __ref: string;
+}
+/**
+ * Discriminated union describing the serialized graph payload.
+ * Each node captures either an array, plain object, or typed payload.
+ */
+type SerializedNode = {
+    kind: "array";
+    value: SerializedValue[];
+} | {
+    kind: "object";
+    value: Record<string, SerializedValue>;
+} | {
+    kind: "type";
+    type: string;
+    value: SerializedValue;
+};
+/**
+ * Serialization context for tracking object references
+ */
+interface SerializationContext {
+    /** Map of objects to their IDs */
+    objectIds: WeakMap<object, string>;
+    /** Counter for generating unique IDs */
+    idCounter: number;
+    /** Number of graph nodes recorded */
+    nodeCount: number;
+    /** Nodes collected during serialization (id -> serialized node) */
+    nodes: Record<string, SerializedNode>;
+}
+/**
+ * Deserialization context used when materialising a graph payload.
+ */
+interface DeserializationContext {
+    nodes: Record<string, SerializedNode>;
+    resolved: Map<string, unknown>;
+    resolving: Set<string>;
+    /**
+     * Tracks reference ids that were requested while still being resolved.
+     * Used to detect circular references that rely on placeholders.
+     */
+    resolvingRefs: Set<string>;
+}
+/**
+ * Union type for serialized values
+ */
+type JsonPrimitive = string | number | boolean | null;
+interface SerializedTypeRecord {
+    __type: string;
+    value: SerializedValue;
+}
+type SerializedValue = JsonPrimitive | ObjectReference | SerializedTypeRecord | SerializedValue[] | {
+    [key: string]: SerializedValue;
+};
+declare enum SymbolPolicy {
+    AllowAll = "AllowAll",
+    WellKnownOnly = "WellKnownOnly",
+    Disabled = "Disabled"
+}
+/**
+ * Main serializer options
+ */
+interface SerializerOptions {
+    /** Whether to pretty-print JSON (for debugging) */
+    pretty?: boolean;
+    /** Maximum recursion depth allowed during serialize/deserialize */
+    maxDepth?: number;
+    /** Restrict deserialization to this list of type IDs */
+    allowedTypes?: readonly string[];
+    /** Controls which Symbol payloads may be deserialized */
+    symbolPolicy?: SymbolPolicy;
+    /** Maximum accepted RegExp pattern length during deserialization */
+    maxRegExpPatternLength?: number;
+    /** Allow RegExp patterns that fail the safety heuristic */
+    allowUnsafeRegExp?: boolean;
+}
+/**
+ * Minimal serializer contract used across transports and persistence.
+ * Implementations must be able to round-trip JSON-compatible payloads and
+ * should support custom value types via `addType`.
+ */
+interface SerializerLike {
     stringify(value: unknown): string;
     parse<T = unknown>(text: string): T;
-    addType?<TJson = unknown, T = unknown>(name: string, factory: (json: TJson) => T): void;
+    addType?<TJson = unknown, TInstance = unknown>(name: string, factory: (json: TJson) => TInstance): void;
+}
+
+/**
+ * Graph-aware serializer/deserializer with circular reference
+ * handling and pluggable type support.
+ *
+ * Internal protocol reference: `readmes/SERIALIZER_PROTOCOL.md`.
+ */
+
+declare class Serializer {
+    /** Type registry for managing custom types */
+    private readonly typeRegistry;
+    private readonly runtimeOptions;
+    /** JSON indentation width when pretty printing is enabled */
+    private readonly indent;
+    /** Maximum recursion depth allowed */
+    private readonly maxDepth;
+    /** Maximum allowed RegExp pattern length during deserialization */
+    private readonly maxRegExpPatternLength;
+    /** Allow RegExp patterns that fail the safety heuristic */
+    private readonly allowUnsafeRegExp;
+    /** Disallowed keys that can lead to prototype pollution */
+    private readonly unsafeKeys;
+    constructor(options?: SerializerOptions);
+    /**
+     * Alias of `serialize()` to match the historical tunnel serializer surface.
+     */
+    stringify<T>(value: T): string;
+    /**
+     * Alias of `deserialize()` to match the historical tunnel serializer surface.
+     */
+    parse<T = unknown>(payload: string): T;
+    /**
+     * Serialize an arbitrary value into a JSON string.
+     */
+    serialize<T>(value: T, context?: SerializationContext): string;
+    /**
+     * Deserialize a JSON string back to its original value.
+     */
+    deserialize<T = unknown>(payload: string): T;
+    /**
+     * Register a custom type for serialization/deserialization.
+     */
+    addType<TInstance, TSerialized>(typeDef: TypeDefinition<TInstance, TSerialized>): void;
+    addType<TJson = unknown, TInstance = unknown>(name: string, factory: (json: TJson) => TInstance): void;
+    /**
+     * @internal - Exposed for testing RegExp safety validation
+     */
+    readonly isRegExpPatternSafe: (pattern: string) => boolean;
+    /**
+     * @internal - Exposed for testing quantifier detection
+     */
+    readonly isQuantifierAt: (pattern: string, index: number) => boolean;
+    /**
+     * @internal - Exposed for testing quantifier character detection
+     */
+    readonly isQuantifierChar: (char: string, pattern: string, index: number) => boolean;
+    /**
+     * @internal - Exposed for testing bounded quantifier detection
+     */
+    readonly isBoundedQuantifier: (pattern: string, index: number) => boolean;
+    /**
+     * @internal - Exposed for test compatibility
+     */
+    toNodeRecord(nodes: Record<string, SerializedNode>): Record<string, SerializedNode>;
+    /**
+     * @internal - Exposed for test compatibility
+     */
+    deserializeValue(value: SerializedValue, context: DeserializationContext, depth?: number): unknown;
+    /**
+     * @internal - Exposed for test compatibility
+     */
+    resolveReference(id: string, context: DeserializationContext, depth?: number): unknown;
+    /**
+     * @internal - Exposed for test compatibility
+     */
+    mergePlaceholder(placeholder: unknown, result: unknown): unknown;
+    /**
+     * @internal - Exposed for test compatibility
+     */
+    isSerializedTypeRecord(value: unknown): value is {
+        __type: string;
+        value: unknown;
+    };
+    private jsonStringify;
 }
 
+/**
+ * Main export module for the Serializer
+ */
+
+declare function getDefaultSerializer(): Serializer;
+
 type TunnelMode = "client" | "server" | "both" | "none";
 type TunnelTaskSelector = Array<string | ITask<any, any, any, any, any, any>> | ((task: ITask<any, any, any, any, any, any>) => boolean);
 type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<any>) => boolean);
@@ -1286,17 +1609,23 @@ interface ExposureFetchConfig {
     auth?: ExposureFetchAuthConfig;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
-    serializer: Serializer;
+    serializer: SerializerLike;
     onRequest?: (ctx: {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<any>>;
+    contexts?: Array<IAsyncContext<unknown>>;
     errorRegistry?: Map<string, IErrorHelper<any>>;
 }
 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>;
 }
 
 declare function normalizeError(input: unknown): Error;
@@ -1319,7 +1648,7 @@ interface HttpCreateClientConfig {
     auth?: HttpClientAuthConfig;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
-    serializer: Serializer;
+    serializer: SerializerLike;
     onRequest?: (ctx: {
         url: string;
         headers: Record<string, string>;
@@ -1327,19 +1656,27 @@ interface HttpCreateClientConfig {
 }
 
 type TunnelMiddlewareId = string | ITaskMiddleware<any, any, any, any>;
+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[];
+}
+type TunnelTaskMiddlewarePolicySideConfig = TunnelTaskMiddlewareSidePolicy | TunnelMiddlewareId[];
 interface TunnelTaskMiddlewarePolicyConfig {
     /**
-     * Whitelist of middleware ids/definitions allowed to run on the caller side
-     * when the task is tunneled (mode: "client"). If omitted, defaults to
-     * allowing all (the framework default remains "both").
+     * Preferred configuration shape: explicit per-side allowlist.
      */
-    client?: TunnelMiddlewareId[];
+    client?: TunnelTaskMiddlewarePolicySideConfig;
+    server?: TunnelTaskMiddlewarePolicySideConfig;
     /**
-     * Whitelist of middleware ids/definitions intended to run on the executor side.
-     * Note: The local runner cannot enforce server-side policy; this is a declarative
-     * contract that a Runner-based executor can consume to apply a symmetric filter.
+     * Backwards-compatible configuration shape (previous): grouped allowlists.
      */
-    server?: TunnelMiddlewareId[];
+    middlewareAllowList?: {
+        client?: TunnelMiddlewareId[];
+        server?: TunnelMiddlewareId[];
+    };
 }
 
 interface TimeoutMiddlewareConfig {
@@ -1370,6 +1707,182 @@ interface RetryMiddlewareConfig {
     delayStrategy?: (attempt: number, error: Error) => number;
 }
 
+interface FallbackMiddlewareConfig {
+    /**
+     * The fallback to use if the task fails.
+     * Can be a value, a function that returns a value (or promise), or another task.
+     */
+    fallback: any;
+}
+
+declare const SemaphoreEvents: {
+    readonly queued: IEvent<SemaphoreEvent>;
+    readonly acquired: IEvent<SemaphoreEvent>;
+    readonly released: IEvent<SemaphoreEvent>;
+    readonly timeout: IEvent<SemaphoreEvent>;
+    readonly aborted: IEvent<SemaphoreEvent>;
+    readonly disposed: IEvent<SemaphoreEvent>;
+};
+type SemaphoreEventType = keyof typeof SemaphoreEvents;
+type SemaphoreEvent = {
+    type: SemaphoreEventType;
+    permits: number;
+    waiting: number;
+    maxPermits: number;
+    disposed: boolean;
+};
+/**
+ * A semaphore that limits the number of concurrent operations.
+ * Used to prevent connection pool exhaustion by limiting concurrent
+ * database operations to the pool size.
+ */
+declare class Semaphore {
+    private permits;
+    private waitingHead;
+    private waitingTail;
+    private waitingCount;
+    private disposed;
+    private readonly maxPermits;
+    private readonly eventManager;
+    private listenerId;
+    private activeListeners;
+    constructor(maxPermits: number);
+    /**
+     * Acquire a permit. If no permits are available, waits until one becomes available.
+     */
+    acquire(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Release a permit, allowing waiting operations to proceed.
+     */
+    release(): void;
+    private removeFromQueue;
+    /**
+     * Execute a function with a permit, automatically releasing it afterwards.
+     */
+    withPermit<T>(fn: () => Promise<T>, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    /**
+     * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
+     */
+    dispose(): void;
+    /**
+     * Get current number of available permits (for debugging)
+     */
+    getAvailablePermits(): number;
+    /**
+     * Get current number of waiting operations (for debugging)
+     */
+    getWaitingCount(): number;
+    /**
+     * Get maximum number of permits
+     */
+    getMaxPermits(): number;
+    /**
+     * Check if the semaphore has been disposed
+     */
+    isDisposed(): boolean;
+    /**
+     * Get metrics about the current state of the semaphore
+     */
+    getMetrics(): {
+        availablePermits: number;
+        waitingCount: number;
+        maxPermits: number;
+        utilization: number;
+        disposed: boolean;
+    };
+    on(type: SemaphoreEventType, handler: (event: SemaphoreEvent) => any): () => void;
+    once(type: SemaphoreEventType, handler: (event: SemaphoreEvent) => any): () => void;
+    private enqueue;
+    private dequeue;
+    private emit;
+    private buildEvent;
+}
+
+interface ConcurrencyMiddlewareConfig {
+    /**
+     * Maximum number of concurrent executions.
+     * If provided, a Semaphore will be created and shared for this config object.
+     */
+    limit?: number;
+    /**
+     * Optional key to identify a shared semaphore.
+     * If provided, the semaphore will be shared across all tasks using the same key.
+     */
+    key?: string;
+    /**
+     * An existing Semaphore instance to use.
+     */
+    semaphore?: Semaphore;
+}
+
+interface TemporalMiddlewareConfig {
+    ms: number;
+}
+interface DebounceState {
+    timeoutId?: NodeJS.Timeout;
+    latestInput?: any;
+    resolveList: ((value: any) => void)[];
+    rejectList: ((error: any) => void)[];
+}
+interface ThrottleState {
+    lastExecution: number;
+    timeoutId?: NodeJS.Timeout;
+    latestInput?: any;
+    resolveList: ((value: any) => void)[];
+    rejectList: ((error: any) => void)[];
+    currentPromise?: Promise<any>;
+}
+
+/**
+ * States of the Circuit Breaker
+ */
+declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+/**
+ * Configuration for the Circuit Breaker middleware
+ */
+interface CircuitBreakerMiddlewareConfig {
+    /**
+     * Number of failures before tripping the circuit
+     * @default 5
+     */
+    failureThreshold?: number;
+    /**
+     * Time in milliseconds before transitioning from OPEN to HALF_OPEN
+     * @default 30000 (30 seconds)
+     */
+    resetTimeout?: number;
+}
+interface CircuitBreakerStatus {
+    state: CircuitBreakerState;
+    failures: number;
+    lastFailureTime: number;
+}
+
+interface RateLimitMiddlewareConfig {
+    /**
+     * Time window in milliseconds
+     */
+    windowMs: number;
+    /**
+     * Maximum number of requests within the window
+     */
+    max: number;
+}
+interface RateLimitState {
+    count: number;
+    resetTime: number;
+}
+
 /**
  * Options for configuring event listeners.
  */
@@ -1404,9 +1917,9 @@ declare class EventManager {
     private hookInterceptors;
     private readonly registry;
     private readonly cycleContext;
-    private readonly runtimeCycleDetection;
+    private readonly runtimeEventCycleDetection;
     constructor(options?: {
-        runtimeCycleDetection?: boolean;
+        runtimeEventCycleDetection?: boolean;
     });
     /**
      * Gets the current lock status of the EventManager
@@ -1425,6 +1938,16 @@ declare class EventManager {
      * @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.
@@ -1479,6 +2002,16 @@ declare class EventManager {
      * Throws an error if the EventManager is locked
      */
     private checkLock;
+    /**
+     * Clears all listeners and interceptors.
+     * Call this to release references and free memory.
+     */
+    clear(): void;
+    /**
+     * Disposes the EventManager, releasing all listeners and interceptors.
+     * Alias for clear() following the IResource disposal pattern.
+     */
+    dispose(): void;
     /**
      * Retrieves cached merged listeners for an event, or creates them if not cached.
      * Kept for backward compatibility (tests spy on this).
@@ -1490,7 +2023,7 @@ declare class TaskRunner {
     protected readonly store: Store;
     protected readonly eventManager: EventManager;
     protected readonly logger: Logger;
-    protected readonly runnerStore: Map<string | symbol, (input: any) => Promise<any>>;
+    protected readonly runnerStore: Map<string | symbol, (input: any, journal?: ExecutionJournal) => Promise<any>>;
     constructor(store: Store, eventManager: EventManager, logger: Logger);
     private readonly middlewareManager;
     /**
@@ -1498,8 +2031,9 @@ declare class TaskRunner {
      * This function can throw only if any of the event listeners or run function throws
      * @param task the task to be run
      * @param input the input to be passed to the task
+     * @param options optional call options including journal for forwarding
      */
-    run<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>, input?: TInput): Promise<TOutput | undefined>;
+    run<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>, input?: TInput, options?: TaskCallOptions): Promise<TOutput | undefined>;
     /**
      * Creates the function with the chain of middleware.
      * @param task
@@ -1507,7 +2041,7 @@ declare class TaskRunner {
      * @param taskDependencies
      * @returns
      */
-    protected createRunnerWithMiddleware<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: TInput) => Promise<Awaited<TOutput>>;
+    protected createRunnerWithMiddleware<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: TInput, parentJournal?: ExecutionJournal) => Promise<Awaited<TOutput>>;
 }
 
 /**
@@ -1571,7 +2105,7 @@ declare class MiddlewareManager {
      * 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>>;
+    composeTaskRunner<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: TInput, parentJournal?: ExecutionJournal) => Promise<Awaited<TOutput>>;
     /**
      * Run a resource init wrapped with its applicable middlewares.
      */
@@ -1602,6 +2136,7 @@ declare class Store {
     private validator;
     private taskRunner?;
     private middlewareManager;
+    private readonly initializedResourceIds;
     mode: RunnerMode;
     constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError, mode?: RunnerMode);
     get tasks(): Map<string, TaskStoreElementType>;
@@ -1613,7 +2148,7 @@ declare class Store {
     get taskMiddlewares(): Map<string, TaskMiddlewareStoreElementType>;
     get resourceMiddlewares(): Map<string, ResourceMiddlewareStoreElementType>;
     get tags(): Map<string, ITag<void, void, void>>;
-    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | ITask<any, any, {}, any, TagType[], TaskMiddlewareAttachmentType[]> | IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | IResourceWithConfig<any, Promise<any>, any, any, any, TagType[], IResourceMiddleware<any, void, void, any>[]>>;
+    get overrides(): Map<string, ITask<any, any, {}, any, TagType[], TaskMiddlewareAttachmentType[]> | IResourceMiddleware<any, void, void, any> | IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | IResourceWithConfig<any, Promise<any>, any, any, any, TagType[], IResourceMiddleware<any, void, void, any>[]>>;
     get overrideRequests(): Set<{
         source: string;
         override: RegisterableItems;
@@ -1629,6 +2164,8 @@ declare class Store {
     validateEventEmissionGraph(): void;
     initializeStore(root: IResource<any, any, any, any, any>, config: any): void;
     dispose(): Promise<void>;
+    recordResourceInitialized(resourceId: string): void;
+    private getResourcesInDisposeOrder;
     /**
      * Internal, avoid using this method directly.
      */
@@ -1664,16 +2201,14 @@ declare class ResourceInitializer {
      * 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;
+        value: TValue | undefined;
         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>;
 }
 
 /**
- * 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.
+ * Resolves and caches computed dependencies for store items (resources, tasks, middleware, hooks).
  */
 declare class DependencyProcessor {
     protected readonly store: Store;
@@ -1683,21 +2218,21 @@ declare class DependencyProcessor {
     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.
+     * Computes and caches dependencies for all registered store items.
      */
     computeAllDependencies(): Promise<void>;
     private computeTaskDependencies;
     initializeUninitializedResources(): Promise<void>;
+    private rethrowResourceInitError;
     /**
-     * Processes dependencies and hooks
-     * @param resource
+     * 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>;
     /**
-     * Processes all hooks, should run before emission of any event.
+     * Attaches listeners for all hooks. Must run before emitting events.
      */
     attachListeners(): void;
     extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
@@ -1708,72 +2243,25 @@ declare class DependencyProcessor {
      * @returns
      */
     extractEventDependency(object: IEvent<any>, source: string): (input: any) => Promise<void>;
-    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown) => Promise<any>>;
+    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown, options?: TaskCallOptions) => Promise<any>>;
     extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
 }
 
-/**
- * A semaphore that limits the number of concurrent operations.
- * Used to prevent connection pool exhaustion by limiting concurrent
- * database operations to the pool size.
- */
-declare class Semaphore {
-    private permits;
-    private readonly waitingQueue;
-    private disposed;
-    private readonly maxPermits;
-    constructor(maxPermits: number);
-    /**
-     * Acquire a permit. If no permits are available, waits until one becomes available.
-     */
-    acquire(options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Release a permit, allowing waiting operations to proceed.
-     */
-    release(): void;
-    private removeFromQueue;
-    /**
-     * Execute a function with a permit, automatically releasing it afterwards.
-     */
-    withPermit<T>(fn: () => Promise<T>, options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<T>;
-    /**
-     * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
-     */
-    dispose(): void;
-    /**
-     * Get current number of available permits (for debugging)
-     */
-    getAvailablePermits(): number;
-    /**
-     * Get current number of waiting operations (for debugging)
-     */
-    getWaitingCount(): number;
-    /**
-     * Get maximum number of permits
-     */
-    getMaxPermits(): number;
-    /**
-     * Check if the semaphore has been disposed
-     */
-    isDisposed(): boolean;
-    /**
-     * Get metrics about the current state of the semaphore
-     */
-    getMetrics(): {
-        availablePermits: number;
-        waitingCount: number;
-        maxPermits: number;
-        utilization: number;
-        disposed: boolean;
-    };
-}
-
+declare const QueueEvents: {
+    readonly enqueue: IEvent<QueueEvent>;
+    readonly start: IEvent<QueueEvent>;
+    readonly finish: IEvent<QueueEvent>;
+    readonly error: IEvent<QueueEvent>;
+    readonly cancel: IEvent<QueueEvent>;
+    readonly disposed: IEvent<QueueEvent>;
+};
+type QueueEventType = keyof typeof QueueEvents;
+type QueueEvent = {
+    type: QueueEventType;
+    taskId: number;
+    disposed: boolean;
+    error?: Error;
+};
 /**
  * Cooperative task queue.
  *  • Tasks run one‑after‑another (FIFO ordering).
@@ -1784,6 +2272,10 @@ declare class Queue {
     private tail;
     private disposed;
     private abortController;
+    private readonly eventManager;
+    private nextTaskId;
+    private listenerId;
+    private activeListeners;
     private readonly executionContext;
     private readonly hasAsyncLocalStorage;
     /**
@@ -1799,6 +2291,9 @@ declare class Queue {
     dispose(options?: {
         cancel?: boolean;
     }): Promise<void>;
+    on(type: QueueEventType, handler: (event: QueueEvent) => any): () => void;
+    once(type: QueueEventType, handler: (event: QueueEvent) => any): () => void;
+    private emit;
 }
 
 declare class RunResult<V> {
@@ -1876,8 +2371,9 @@ type AnyResource = IResource<any, any, any, any, any, any, any>;
 type AnyTaskMiddleware = ITaskMiddleware<any, any, any, any>;
 type AnyResourceMiddleware = IResourceMiddleware<any, any, any, any>;
 type AnyHook = IHook<any, any, any>;
-type OverridePatch<T> = T extends AnyTask ? Omit<Partial<T>, "id"> & Pick<T, "run"> : T extends AnyResource ? Omit<Partial<T>, "id"> & Pick<T, "init"> : T extends AnyTaskMiddleware ? Omit<Partial<T>, "id"> : T extends AnyResourceMiddleware ? Omit<Partial<T>, "id"> & Pick<T, "run"> : T extends AnyHook ? Omit<Partial<T>, "id" | "on"> & Pick<T, "run"> : never;
-declare function defineOverride<T extends AnyTask | AnyResource | AnyTaskMiddleware | AnyResourceMiddleware | AnyHook>(base: T, patch: OverridePatch<T>): T;
+type AnyOverrideable = AnyTask | AnyResource | AnyTaskMiddleware | AnyResourceMiddleware | AnyHook;
+type OverridePatch<TBase extends AnyOverrideable> = Readonly<TBase extends AnyHook ? Omit<Partial<TBase>, "id" | "on"> : Omit<Partial<TBase>, "id">>;
+declare function defineOverride<TBase extends AnyOverrideable>(base: TBase, patch: OverridePatch<TBase>): TBase;
 
 /**
  * Create a tag definition.
@@ -1932,68 +2428,83 @@ declare class PlatformAdapter implements IPlatformAdapter {
     clearTimeout: typeof clearTimeout;
 }
 
-declare const duplicateRegistrationError: ErrorHelper<{
+declare const duplicateRegistrationError: IErrorHelper<{
     type: string;
     id: string;
 } & DefaultErrorType>;
-declare const dependencyNotFoundError: ErrorHelper<{
+declare const dependencyNotFoundError: IErrorHelper<{
     key: string;
 } & DefaultErrorType>;
-declare const unknownItemTypeError: ErrorHelper<{
+declare const unknownItemTypeError: IErrorHelper<{
     item: unknown;
 } & DefaultErrorType>;
-declare const contextError: ErrorHelper<{
+declare const contextError: IErrorHelper<{
     details?: string;
 } & DefaultErrorType>;
-declare const circularDependenciesError: ErrorHelper<{
+declare const circularDependenciesError: IErrorHelper<{
     cycles: string[];
 } & DefaultErrorType>;
-declare const eventNotFoundError: ErrorHelper<{
+declare const eventNotFoundError: IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-declare const resourceNotFoundError: ErrorHelper<{
+declare const resourceNotFoundError: IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-declare const middlewareNotRegisteredError: ErrorHelper<{
+declare const middlewareNotRegisteredError: IErrorHelper<{
     type: "task" | "resource";
     source: string;
     middlewareId: string;
 } & DefaultErrorType>;
-declare const tagNotFoundError: ErrorHelper<{
+declare const tagNotFoundError: IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-declare const lockedError: ErrorHelper<{
+declare const lockedError: IErrorHelper<{
     what: string;
 } & DefaultErrorType>;
-declare const storeAlreadyInitializedError: ErrorHelper<DefaultErrorType>;
-declare const validationError: ErrorHelper<{
+declare const storeAlreadyInitializedError: IErrorHelper<DefaultErrorType>;
+declare const validationError: IErrorHelper<{
     subject: string;
     id: string;
     originalError: string | Error;
 } & DefaultErrorType>;
-declare const eventCycleError: ErrorHelper<{
+declare const eventCycleError: IErrorHelper<{
     path: Array<{
         id: string;
         source: string;
     }>;
 } & DefaultErrorType>;
-declare const eventEmissionCycleError: ErrorHelper<{
+declare const eventEmissionCycleError: IErrorHelper<{
     cycles: string[];
 } & DefaultErrorType>;
-declare const platformUnsupportedFunctionError: ErrorHelper<{
+declare const platformUnsupportedFunctionError: IErrorHelper<{
     functionName: string;
 } & DefaultErrorType>;
-declare const cancellationError: ErrorHelper<{
+declare const cancellationError: IErrorHelper<{
     reason?: string;
 } & DefaultErrorType>;
-declare const tunnelOwnershipConflictError: ErrorHelper<{
+declare const tunnelOwnershipConflictError: IErrorHelper<{
     taskId: string;
     currentOwnerId: string;
     attemptedOwnerId: string;
 } & DefaultErrorType>;
+declare const phantomTaskNotRoutedError: IErrorHelper<{
+    taskId: string;
+} & DefaultErrorType>;
+declare const taskNotRegisteredError: IErrorHelper<{
+    taskId: string;
+} & DefaultErrorType>;
+/** Builder types that require validation before build() */
+type BuilderType = "hook" | "task-middleware" | "resource-middleware";
+declare const builderIncompleteError: IErrorHelper<{
+    type: BuilderType;
+    builderId: string;
+    missingFields: string[];
+} & DefaultErrorType>;
 declare function isCancellationError(err: unknown): boolean;
 
+type errors_BuilderType = BuilderType;
 type errors_IErrorHelper<TData extends DefaultErrorType = DefaultErrorType> = IErrorHelper<TData>;
+declare const errors_builderIncompleteError: typeof builderIncompleteError;
 declare const errors_cancellationError: typeof cancellationError;
 declare const errors_circularDependenciesError: typeof circularDependenciesError;
 declare const errors_contextError: typeof contextError;
@@ -2005,15 +2516,17 @@ declare const errors_eventNotFoundError: typeof eventNotFoundError;
 declare const errors_isCancellationError: typeof isCancellationError;
 declare const errors_lockedError: typeof lockedError;
 declare const errors_middlewareNotRegisteredError: typeof middlewareNotRegisteredError;
+declare const errors_phantomTaskNotRoutedError: typeof phantomTaskNotRoutedError;
 declare const errors_platformUnsupportedFunctionError: typeof platformUnsupportedFunctionError;
 declare const errors_resourceNotFoundError: typeof resourceNotFoundError;
 declare const errors_storeAlreadyInitializedError: typeof storeAlreadyInitializedError;
 declare const errors_tagNotFoundError: typeof tagNotFoundError;
+declare const errors_taskNotRegisteredError: typeof taskNotRegisteredError;
 declare const errors_tunnelOwnershipConflictError: typeof tunnelOwnershipConflictError;
 declare const errors_unknownItemTypeError: typeof unknownItemTypeError;
 declare const errors_validationError: typeof validationError;
 declare namespace errors {
-  export { type errors_IErrorHelper as IErrorHelper, errors_cancellationError as cancellationError, errors_circularDependenciesError as circularDependenciesError, errors_contextError as contextError, errors_dependencyNotFoundError as dependencyNotFoundError, errors_duplicateRegistrationError as duplicateRegistrationError, errors_eventCycleError as eventCycleError, errors_eventEmissionCycleError as eventEmissionCycleError, errors_eventNotFoundError as eventNotFoundError, errors_isCancellationError as isCancellationError, errors_lockedError as lockedError, errors_middlewareNotRegisteredError as middlewareNotRegisteredError, errors_platformUnsupportedFunctionError as platformUnsupportedFunctionError, errors_resourceNotFoundError as resourceNotFoundError, errors_storeAlreadyInitializedError as storeAlreadyInitializedError, errors_tagNotFoundError as tagNotFoundError, errors_tunnelOwnershipConflictError as tunnelOwnershipConflictError, errors_unknownItemTypeError as unknownItemTypeError, errors_validationError as validationError };
+  export { type errors_BuilderType as BuilderType, type errors_IErrorHelper as IErrorHelper, errors_builderIncompleteError as builderIncompleteError, errors_cancellationError as cancellationError, errors_circularDependenciesError as circularDependenciesError, errors_contextError as contextError, errors_dependencyNotFoundError as dependencyNotFoundError, errors_duplicateRegistrationError as duplicateRegistrationError, errors_eventCycleError as eventCycleError, errors_eventEmissionCycleError as eventEmissionCycleError, errors_eventNotFoundError as eventNotFoundError, errors_isCancellationError as isCancellationError, errors_lockedError as lockedError, errors_middlewareNotRegisteredError as middlewareNotRegisteredError, errors_phantomTaskNotRoutedError as phantomTaskNotRoutedError, errors_platformUnsupportedFunctionError as platformUnsupportedFunctionError, errors_resourceNotFoundError as resourceNotFoundError, errors_storeAlreadyInitializedError as storeAlreadyInitializedError, errors_tagNotFoundError as tagNotFoundError, errors_taskNotRegisteredError as taskNotRegisteredError, errors_tunnelOwnershipConflictError as tunnelOwnershipConflictError, errors_unknownItemTypeError as unknownItemTypeError, errors_validationError as validationError };
 }
 
 /**
@@ -2061,6 +2574,27 @@ declare function buildTestFacade(deps: {
     eventManager: EventManager;
 };
 
+type HookOn = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
+interface HookOverrideBuilder<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta> {
+    id: string;
+    order(order: number): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    dependencies<TNewDeps extends DependencyMapType, TIsOverride extends boolean = false>(deps: TNewDeps | (() => TNewDeps), options?: {
+        override?: TIsOverride;
+    }): HookOverrideBuilder<TIsOverride extends true ? TNewDeps : TDeps & TNewDeps, TOn, TMeta>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookOverrideBuilder<TDeps, TOn, TNewMeta>;
+    run(fn: IHookDefinition<TDeps, TOn, TMeta>["run"]): HookOverrideBuilder<TDeps, TOn, TMeta>;
+    build(): IHook<TDeps, TOn, TMeta>;
+}
+
+declare function override<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[]>(base: ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+declare function override<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]>(base: IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
+declare function override<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta>(base: IHook<TDeps, TOn, TMeta>): HookOverrideBuilder<TDeps, TOn, TMeta>;
+declare function override<C, In, Out, D extends DependencyMapType>(base: ITaskMiddleware<C, In, Out, D>): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+declare function override<C, In, Out, D extends DependencyMapType>(base: IResourceMiddleware<C, In, Out, D>): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+
 declare const debugLevels: {
     normal: DebugConfig;
     verbose: DebugConfig;
@@ -2081,23 +2615,24 @@ interface HttpClientConfig {
     auth?: HttpClientAuth;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
-    serializer: Serializer;
+    serializer: SerializerLike;
     onRequest?: (ctx: {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<any>>;
+    contexts?: Array<IAsyncContext<unknown>>;
     errorRegistry?: Map<string, IErrorHelper<any>>;
 }
 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>;
 }
 declare function createHttpClient(cfg: HttpClientConfig): HttpClient;
 
 /**
  * Factory for creating HTTP clients with automatic injection of:
- * - serializer (EJSON-compatible)
+ * - serializer
  * - error registry (from Store)
  * - async contexts (from Store)
  *
@@ -2114,6 +2649,40 @@ interface HttpClientFactoryConfig {
 }
 type HttpClientFactory = (config: HttpClientFactoryConfig) => HttpClient;
 
+/**
+ * Implementation of ExecutionJournal.
+ * Created per task execution and passed through the middleware chain.
+ */
+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>;
+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: () => ExecutionJournalImpl;
+};
+
 declare const globals: {
     events: {
         readonly ready: IEvent<void>;
@@ -2124,15 +2693,15 @@ declare const globals: {
         readonly eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         readonly taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         readonly logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        readonly serializer: IResource<void, Promise<Serializer>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+        readonly serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         readonly cache: IResource<{
             defaultOptions?: any;
         }, Promise<{
             map: Map<string, ICacheInstance>;
-            cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
+            cacheFactoryTask: TaskDependencyWithIntercept<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
             defaultOptions: any;
         }>, {
-            cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
+            cacheFactoryTask: ITask<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
         }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         readonly queue: IResource<void, Promise<{
             map: Map<string, Queue>;
@@ -2144,12 +2713,37 @@ declare const globals: {
             description: string;
         }, TagType[], ResourceMiddlewareAttachmentType[]>;
         readonly httpClientFactory: IResource<void, Promise<HttpClientFactory>, {
-            serializer: IResource<void, Promise<Serializer>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+            serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
             store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         }, any, {
             title: string;
             description: string;
         }, TagType[], ResourceMiddlewareAttachmentType[]>;
+        readonly rateLimit: IResource<void, Promise<{
+            states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        readonly circuitBreaker: IResource<void, Promise<{
+            statusMap: Map<string, CircuitBreakerStatus>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        readonly temporal: IResource<void, Promise<{
+            debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
+            throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        readonly concurrency: IResource<void, Promise<{
+            semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
+            semaphoresByKey: Map<string, {
+                semaphore: Semaphore;
+                limit: number;
+            }>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
     };
     middleware: {
         requireContext: ITaskMiddleware<{
@@ -2164,14 +2758,87 @@ declare const globals: {
                     defaultOptions?: any;
                 }, Promise<{
                     map: Map<string, ICacheInstance>;
-                    cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
+                    cacheFactoryTask: TaskDependencyWithIntercept<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
                     defaultOptions: any;
                 }>, {
-                    cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
+                    cacheFactoryTask: ITask<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
                 }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly hit: JournalKey<boolean>;
+                };
+            };
+            concurrency: ITaskMiddleware<ConcurrencyMiddlewareConfig, void, void, {
+                state: IResource<void, Promise<{
+                    semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
+                    semaphoresByKey: Map<string, {
+                        semaphore: Semaphore;
+                        limit: number;
+                    }>;
+                }>, {}, any, any, ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+            }>;
+            debounce: ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
+                state: IResource<void, Promise<{
+                    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
+                    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
+                }>, {}, any, any, ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+            }>;
+            throttle: ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
+                state: IResource<void, Promise<{
+                    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
+                    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
+                }>, {}, any, any, ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
             }>;
-            retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
-            timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>;
+            fallback: ITaskMiddleware<FallbackMiddlewareConfig, void, void, {
+                taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly active: JournalKey<boolean>;
+                    readonly error: JournalKey<Error>;
+                };
+            };
+            rateLimit: ITaskMiddleware<RateLimitMiddlewareConfig, void, void, {
+                state: IResource<void, Promise<{
+                    states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+                }>, {}, any, any, ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly remaining: JournalKey<number>;
+                    readonly resetTime: JournalKey<number>;
+                    readonly limit: JournalKey<number>;
+                };
+            };
+            retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly attempt: JournalKey<number>;
+                    readonly lastError: JournalKey<Error>;
+                };
+            };
+            timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any> & {
+                journalKeys: {
+                    readonly abortController: JournalKey<AbortController>;
+                };
+            };
+            circuitBreaker: ITaskMiddleware<CircuitBreakerMiddlewareConfig, void, void, {
+                state: IResource<void, Promise<{
+                    statusMap: Map<string, CircuitBreakerStatus>;
+                }>, {}, any, any, ITag<{
+                    metadata?: Record<string, any>;
+                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+            }> & {
+                journalKeys: {
+                    readonly state: JournalKey<CircuitBreakerState>;
+                    readonly failures: JournalKey<number>;
+                };
+            };
         };
         resource: {
             retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
@@ -2188,6 +2855,7 @@ declare const globals: {
         debug: ITag<DebugFriendlyConfig, void, void>;
         tunnel: ITag<void, void, TunnelRunner>;
         tunnelPolicy: ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;
+        authValidator: ITag<void, void, void>;
     };
     tunnels: Readonly<{
         http: Readonly<{
@@ -2210,6 +2878,7 @@ declare const r: Readonly<{
     event: typeof eventBuilder;
     hook: typeof hookBuilder;
     tag: typeof tagBuilder;
+    override: typeof override;
     asyncContext: typeof asyncContextBuilder;
     error: typeof errorBuilder;
     middleware: Readonly<{
@@ -2218,4 +2887,4 @@ declare const r: Readonly<{
     }>;
 }>;
 
-export { ASYNC_CONTEXT_TYPES_LOADED, type CommonPayload, type DebugConfig, type DebugFriendlyConfig, type DefaultErrorType, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, ERROR_TYPES_LOADED, errors as Errors, type EventDeliveryMode, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExposureFetchAuthConfig, type ExposureFetchClient, type ExposureFetchConfig, type ExtractEventPayload, type ExtractResourceConfig, type ExtractResourceValue, type ExtractTaskInput, type ExtractTaskOutput, type HookExecutionInterceptor, type HookStoreElementType, type HttpClient, type HttpClientAuth, type HttpClientConfig, type HttpClientFactory, type HttpClientFactoryConfig, type IAsyncContext, type IAsyncContextDefinition, type IAsyncContextMeta, type ICacheInstance, type IErrorDefinition, type IErrorDefinitionFinal, type IErrorHelper, type IErrorMeta, type IEvent, type IEventDefinition, type IEventEmission, type IEventHandlerOptions, type IEventMeta, type IHook, type IHookDefinition, type ILog, type ILogInfo, type IMeta, type IMiddlewareMeta, type IOptionalDependency, type IPhantomTask, type IResource, type IResourceDefinition, type IResourceMeta, type IResourceMiddleware, type IResourceMiddlewareConfigured, type IResourceMiddlewareDefinition, type IResourceMiddlewareExecutionInput, type IResourceWithConfig, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type LogLevels, Logger, MiddlewareManager, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, PlatformAdapter, type PrintStrategy, Queue, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, type ResourceInitFn, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, RunnerMode, Semaphore, type Serializer, Store, type TagType, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type TunnelEventSelector, type TunnelMode, type TunnelRunner, type TunnelTagConfig, type TunnelTaskRunner, type TunnelTaskSelector, type UnhandledErrorKind, type UnionToIntersection, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs as definitions, defineEvent as event, getConfig, globals, defineHook as hook, isOneOf, levelNormal, levelVerbose, normalizeError, onAnyOf, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, symbolAsyncContext, symbolError, symbolEvent, symbolFilePath, symbolHook, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolPhantomTask, symbolResource, symbolResourceMiddleware, symbolResourceWithConfig, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, symbolTunneledBy, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
+export { type CommonPayload, type DebugConfig, type DebugFriendlyConfig, type DefaultErrorType, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, type ErrorReference, errors as Errors, type EventDeliveryMode, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExecutionJournal, type ExposureFetchAuthConfig, type ExposureFetchClient, type ExposureFetchConfig, type ExtractEventPayload, type ExtractResourceConfig, type ExtractResourceValue, type ExtractTaskInput, type ExtractTaskOutput, type HookExecutionInterceptor, type HookStoreElementType, type HttpClient, type HttpClientAuth, type HttpClientConfig, type HttpClientFactory, type HttpClientFactoryConfig, type IAsyncContext, type IAsyncContextDefinition, type IAsyncContextMeta, type ICacheInstance, type IErrorDefinition, type IErrorDefinitionFinal, type IErrorHelper, type IErrorMeta, type IEvent, type IEventDefinition, type IEventEmission, type IEventHandlerOptions, type IEventMeta, type IHook, type IHookDefinition, type ILog, type ILogInfo, type IMeta, type IMiddlewareMeta, type IOptionalDependency, type IPhantomTask, type IResource, type IResourceDefinition, type IResourceMeta, type IResourceMiddleware, type IResourceMiddlewareConfigured, type IResourceMiddlewareDefinition, type IResourceMiddlewareExecutionInput, type IResourceWithConfig, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type JournalKey, type LogLevels, Logger, MiddlewareManager, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, PlatformAdapter, type PrintStrategy, Queue, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, type ResourceInitFn, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, RunnerMode, Semaphore, Serializer, type SerializerOptions, Store, type TagType, type TaskCallOptions, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type ThrowsList, type TunnelEventSelector, type TunnelMode, type TunnelRunner, type TunnelTagConfig, type TunnelTaskRunner, type TunnelTaskSelector, type TypeDefinition, type UnhandledErrorKind, type UnionToIntersection, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs as definitions, defineEvent as event, getConfig, getDefaultSerializer, globals, defineHook as hook, isOneOf, journal, levelNormal, levelVerbose, normalizeError, onAnyOf, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, symbolAsyncContext, symbolError, symbolEvent, symbolFilePath, symbolHook, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolPhantomTask, symbolResource, symbolResourceMiddleware, symbolResourceWithConfig, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, symbolTunneledBy, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };