@bluelibs/runner 4.9.0 → 5.1.0

package/dist/node/node.d.mts

@@ -1,15 +1,212 @@
+import * as lru_cache from 'lru-cache';
 import { Readable } from 'stream';
 export { Readable } from 'stream';
 import * as http from 'http';
 import { IncomingMessage, ServerResponse } from 'http';
-export { EJSON } from '@bluelibs/ejson';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Request, Router } from 'express';
 
-interface Serializer {
+/**
+ * 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;
+
 declare const CONTRACT: unique symbol;
 type CONTRACT = typeof CONTRACT;
 interface IContractable<TConfig = any, TInput = void, TOutput = void> {
@@ -89,7 +286,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>;
@@ -120,7 +317,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> {
@@ -139,6 +336,8 @@ declare const symbolTask: unique symbol;
 /** Marks a task as a phantom task (no-op run; meant to be tunneled/routed). */
 declare const symbolPhantomTask: unique symbol;
 declare const symbolResource: unique symbol;
+/** @internal Marks forked resources and records fork provenance */
+declare const symbolResourceForkedFrom: unique symbol;
 declare const symbolResourceWithConfig: unique symbol;
 declare const symbolEvent: unique symbol;
 /** @internal Marks an error helper definition */
@@ -162,9 +361,107 @@ 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 ResourceForkRegisterMode = "keep" | "drop" | "deep";
+interface ResourceForkOptions {
+    /**
+     * Control whether the fork keeps the base `register` list.
+     * - "keep" (default) keeps registration items
+     * - "drop" clears registration items
+     * - "deep" deep-forks registered resources with new ids (resource tree)
+     */
+    register?: ResourceForkRegisterMode;
+    /**
+     * Used with `register: "deep"` to derive ids for deep-forked resources.
+     * Defaults to `(id) => \`\${newId}.\${id}\``.
+     */
+    reId?: (id: string) => string;
+}
+interface ResourceForkInfo {
+    /** The id of the resource that was forked. */
+    readonly fromId: string;
+    /** Best-effort call-site file path for the fork operation. */
+    readonly forkedAtFilePath: string;
+}
 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. */
@@ -194,6 +491,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.
@@ -230,9 +537,19 @@ interface IResource<TConfig = void, TValue extends Promise<any> = Promise<any>,
     middleware: TMiddleware;
     [symbolFilePath]: string;
     [symbolResource]: true;
+    /** Present only on forked resources. */
+    [symbolResourceForkedFrom]?: ResourceForkInfo;
+    /** 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, options?: ResourceForkOptions): 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;
@@ -244,55 +561,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;
@@ -315,7 +611,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. */
@@ -333,72 +629,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;
+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);
-    /** 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 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> {
-    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;
@@ -476,41 +776,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;
@@ -598,20 +882,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.
  */
@@ -668,7 +963,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?: {
@@ -686,35 +981,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> {
@@ -725,6 +1014,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> {
@@ -734,11 +1027,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;
@@ -750,10 +1051,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;
@@ -772,69 +1083,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?: {
@@ -864,27 +1204,41 @@ 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>;
 }
+
+/**
+ * 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 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 {
@@ -915,63 +1269,249 @@ interface RetryMiddlewareConfig {
     delayStrategy?: (attempt: number, error: Error) => number;
 }
 
-/**
- * Options for configuring event listeners.
- */
-interface IEventHandlerOptions<T = any> {
-    order?: number;
-    filter?: (event: IEventEmission<T>) => boolean;
+interface FallbackMiddlewareConfig {
     /**
-     * Represents the listener ID. Use this to avoid a listener calling itself.
+     * The fallback to use if the task fails.
+     * Can be a value, a function that returns a value (or promise), or another task.
      */
-    id?: string;
+    fallback: any;
 }
-/**
- * Interceptor for event emissions.
- */
-type EventEmissionInterceptor = (next: (event: IEventEmission<any>) => Promise<void>, event: IEventEmission<any>) => Promise<void>;
-/**
- * Interceptor for hook execution.
- */
-type HookExecutionInterceptor = (next: (hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>, hook: IHook<any, any>, event: IEventEmission<any>) => Promise<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;
+};
 /**
- * EventManager handles event emission, listener registration, and event processing.
- * It supports both specific event listeners and global listeners that handle all events.
- * Listeners are processed in order based on their priority.
+ * 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 EventManager {
-    #private;
-    private listeners;
-    private globalListeners;
-    private cachedMergedListeners;
-    private emissionInterceptors;
-    private hookInterceptors;
-    private readonly registry;
-    private readonly cycleContext;
-    private readonly runtimeCycleDetection;
-    constructor(options?: {
-        runtimeCycleDetection?: boolean;
-    });
+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);
     /**
-     * Gets the current lock status of the EventManager
+     * Acquire a permit. If no permits are available, waits until one becomes available.
      */
-    get isLocked(): boolean;
+    acquire(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
-     * Locks the EventManager, preventing any further modifications to listeners
+     * Release a permit, allowing waiting operations to proceed.
      */
-    lock(): void;
+    release(): void;
+    private removeFromQueue;
     /**
-     * Emits an event to all registered listeners for that event type.
-     * Listeners are processed in order of priority and can stop event propagation.
-     *
-     * @param eventDefinition - The event definition to emit
-     * @param data - The event payload data
-     * @param source - The source identifier of the event emitter
+     * Execute a function with a permit, automatically releasing it afterwards.
      */
-    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<void>;
+    withPermit<T>(fn: () => Promise<T>, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
-     * Registers an event listener for specific event(s).
+     * 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.
+ */
+interface IEventHandlerOptions<T = any> {
+    order?: number;
+    filter?: (event: IEventEmission<T>) => boolean;
+    /**
+     * Represents the listener ID. Use this to avoid a listener calling itself.
+     */
+    id?: string;
+}
+/**
+ * Interceptor for event emissions.
+ */
+type EventEmissionInterceptor = (next: (event: IEventEmission<any>) => Promise<void>, event: IEventEmission<any>) => Promise<void>;
+/**
+ * Interceptor for hook execution.
+ */
+type HookExecutionInterceptor = (next: (hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>, hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>;
+
+/**
+ * EventManager handles event emission, listener registration, and event processing.
+ * It supports both specific event listeners and global listeners that handle all events.
+ * Listeners are processed in order based on their priority.
+ */
+declare class EventManager {
+    #private;
+    private listeners;
+    private globalListeners;
+    private cachedMergedListeners;
+    private emissionInterceptors;
+    private hookInterceptors;
+    private readonly registry;
+    private readonly cycleContext;
+    private readonly runtimeEventCycleDetection;
+    constructor(options?: {
+        runtimeEventCycleDetection?: boolean;
+    });
+    /**
+     * Gets the current lock status of the EventManager
+     */
+    get isLocked(): boolean;
+    /**
+     * Locks the EventManager, preventing any further modifications to listeners
+     */
+    lock(): void;
+    /**
+     * Emits an event to all registered listeners for that event type.
+     * Listeners are processed in order of priority and can stop event propagation.
+     *
+     * @param eventDefinition - The event definition to emit
+     * @param data - The event payload data
+     * @param source - The source identifier of the event emitter
+     */
+    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<void>;
+    /**
+     * Emits an event and returns the final payload.
+     * The payload is taken from the deepest emission object that reached either:
+     * - the base listener executor, or
+     * - an interceptor that short-circuited the emission.
+     *
+     * This enables tunnel transports to return the final payload after local and/or remote delivery.
+     */
+    emitWithResult<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<TInput>;
+    private emitAndReturnEmission;
+    /**
+     * Registers an event listener for specific event(s).
      * Listeners are ordered by priority and executed in ascending order.
      *
      * @param event - The event definition(s) to listen for
@@ -1024,6 +1564,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).
@@ -1079,6 +1629,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;
@@ -1208,7 +1759,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;
     /**
@@ -1216,8 +1767,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
@@ -1225,7 +1777,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>>;
 }
 
 type UnhandledErrorKind = "process" | "task" | "middleware" | "resourceInit" | "hook" | "run";
@@ -1300,7 +1852,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.
      */
@@ -1331,6 +1883,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>;
@@ -1358,6 +1911,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.
      */
@@ -1393,16 +1948,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;
@@ -1412,21 +1965,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>>;
@@ -1437,72 +1990,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).
@@ -1513,6 +2019,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;
     /**
@@ -1528,6 +2038,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> {
@@ -1605,8 +2118,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.
@@ -1661,68 +2175,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;
@@ -1734,15 +2263,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 };
 }
 
 /**
@@ -1778,6 +2309,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>;
+
 type DebugConfig = {
     logResourceConfig: boolean;
     logResourceValue: boolean;
@@ -1823,23 +2375,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)
  *
@@ -1856,6 +2409,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 createContext: typeof createContext$1;
 
 declare const r: Readonly<{
@@ -1864,6 +2451,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<{
@@ -1922,7 +2510,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.
@@ -1942,6 +2530,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;
 }
 
 /**
@@ -1961,13 +2551,12 @@ interface ICacheInstance {
  * - 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>;
@@ -1995,7 +2584,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>;
@@ -2004,7 +2593,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>;
@@ -2020,6 +2609,9 @@ type defs_RegisterableItems = RegisterableItems;
 type defs_RequiredKeys<T> = RequiredKeys<T>;
 type defs_ResourceDependencyValueType<T> = ResourceDependencyValueType<T>;
 type defs_ResourceDependencyValuesType<T extends DependencyMapType> = ResourceDependencyValuesType<T>;
+type defs_ResourceForkInfo = ResourceForkInfo;
+type defs_ResourceForkOptions = ResourceForkOptions;
+type defs_ResourceForkRegisterMode = ResourceForkRegisterMode;
 type defs_ResourceInitFn<TConfig, TValue extends Promise<any>, TDependencies extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]> = ResourceInitFn<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
 type defs_ResourceMiddlewareAttachmentType = ResourceMiddlewareAttachmentType;
 type defs_ResourceMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = ResourceMiddlewareStoreElementType<TDeps>;
@@ -2028,11 +2620,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;
@@ -2046,6 +2640,7 @@ declare const defs_symbolMiddlewareConfigured: typeof symbolMiddlewareConfigured
 declare const defs_symbolOptionalDependency: typeof symbolOptionalDependency;
 declare const defs_symbolPhantomTask: typeof symbolPhantomTask;
 declare const defs_symbolResource: typeof symbolResource;
+declare const defs_symbolResourceForkedFrom: typeof symbolResourceForkedFrom;
 declare const defs_symbolResourceMiddleware: typeof symbolResourceMiddleware;
 declare const defs_symbolResourceWithConfig: typeof symbolResourceWithConfig;
 declare const defs_symbolTag: typeof symbolTag;
@@ -2054,7 +2649,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_ResourceForkInfo as ResourceForkInfo, type defs_ResourceForkOptions as ResourceForkOptions, type defs_ResourceForkRegisterMode as ResourceForkRegisterMode, 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_symbolResourceForkedFrom as symbolResourceForkedFrom, 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 };
 }
 
 type TunnelMode = "client" | "server" | "both" | "none";
@@ -2082,17 +2677,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;
@@ -2115,12 +2716,35 @@ interface HttpCreateClientConfig {
     auth?: HttpClientAuthConfig;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
-    serializer: Serializer;
+    serializer: SerializerLike;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+
+interface HttpSmartClientAuthConfig {
+    header?: string;
+    token: string;
+}
+interface HttpSmartClientConfig {
+    baseUrl: string;
+    auth?: HttpSmartClientAuthConfig;
+    timeoutMs?: number;
+    serializer: SerializerLike;
     onRequest?: (ctx: {
         url: string;
         headers: Record<string, string>;
     }) => void | Promise<void>;
+    contexts?: Array<IAsyncContext<unknown>>;
+    errorRegistry?: Map<string, IErrorHelper<any>>;
+}
+interface HttpSmartClient {
+    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable>;
+    event<P = unknown>(id: string, payload?: P): Promise<void>;
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
 }
+declare function createHttpSmartClient(cfg: HttpSmartClientConfig): HttpSmartClient;
 
 interface MixedHttpClientAuthConfig {
     header?: string;
@@ -2131,24 +2755,52 @@ interface MixedHttpClientConfig {
     auth?: MixedHttpClientAuthConfig;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
-    serializer: Serializer;
+    /**
+     * Forces the Smart client path even for plain JSON inputs.
+     *
+     * Use this when a task may return a stream even when its input is not a stream
+     * and does not include Node File sentinels (ex: download endpoints).
+     *
+     * - `true`: always use Smart for tasks
+     * - predicate: use Smart for selected task ids/inputs
+     */
+    forceSmart?: boolean | ((ctx: {
+        id: string;
+        input: unknown;
+    }) => boolean | Promise<boolean>);
+    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 MixedHttpClient {
     task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable | ReadableStream<Uint8Array>>;
     event<P = unknown>(id: string, payload?: P): Promise<void>;
+    eventWithResult?<P = unknown>(id: string, payload?: P): Promise<P>;
 }
 /**
- * Unified Node client that mixes JSON/EJSON fetch for standard calls and
+ * Unified Node client that mixes JSON fetch for standard calls and
  * Smart client for streaming/multipart. Keeps transport details out of app code.
  */
 declare function createHttpMixedClient(cfg: MixedHttpClientConfig): MixedHttpClient;
 
+interface HttpSmartClientFactoryConfig {
+    baseUrl: string;
+    auth?: {
+        header?: string;
+        token: string;
+    };
+    timeoutMs?: number;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
+
 interface HttpMixedClientFactoryConfig {
     baseUrl: string;
     auth?: {
@@ -2164,57 +2816,21 @@ interface HttpMixedClientFactoryConfig {
 }
 type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
 
-interface HttpSmartClientAuthConfig {
-    header?: string;
-    token: string;
-}
-interface HttpSmartClientConfig {
-    baseUrl: string;
-    auth?: HttpSmartClientAuthConfig;
-    timeoutMs?: number;
-    serializer: Serializer;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<any>>;
-    errorRegistry?: Map<string, IErrorHelper<any>>;
-}
-interface HttpSmartClient {
-    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O | Readable>;
-    event<P = unknown>(id: string, payload?: P): Promise<void>;
-}
-declare function createHttpSmartClient(cfg: HttpSmartClientConfig): HttpSmartClient;
-
-interface HttpSmartClientFactoryConfig {
-    baseUrl: string;
-    auth?: {
-        header?: string;
-        token: string;
-    };
-    timeoutMs?: number;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-}
-type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
-
 declare const globalResources: {
     readonly store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
     readonly middlewareManager: IResource<void, Promise<MiddlewareManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
     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>;
@@ -2226,19 +2842,65 @@ declare const globalResources: {
         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[]>;
 };
 
 interface NodeExposureHttpAuthConfig {
     header?: string;
-    token: string;
+    token?: string | string[];
+    /**
+     * When true, allows unauthenticated access if no token or validators are configured.
+     * Defaults to false (secure by default - requires explicit auth configuration).
+     *
+     * WARNING: Setting this to true without proper network isolation exposes
+     * all tasks and events to unauthenticated access.
+     */
+    allowAnonymous?: boolean;
+}
+
+interface MultipartLimits {
+    fieldNameSize?: number;
+    fieldSize?: number;
+    fields?: number;
+    fileSize?: number;
+    files?: number;
+    parts?: number;
+    headerPairs?: number;
 }
 
+interface JsonLimits {
+    maxSize?: number;
+}
 type NodeExposureDependencyMap = {
     store: typeof globalResources.store;
     taskRunner: typeof globalResources.taskRunner;
@@ -2256,6 +2918,15 @@ interface NodeExposureHttpConfig {
     };
     auth?: NodeExposureHttpAuthConfig;
     cors?: NodeExposureHttpCorsConfig;
+    limits?: {
+        json?: JsonLimits;
+        multipart?: MultipartLimits;
+    };
+    /**
+     * Opt out of fail-closed exposure (not recommended).
+     * When true and no server-mode tunnel is registered, exposure is open.
+     */
+    dangerouslyAllowOpenExposure?: boolean;
 }
 interface NodeExposureConfig {
     http?: NodeExposureHttpConfig;
@@ -2300,7 +2971,7 @@ declare const nodeExposure: IResource<NodeExposureConfig, Promise<NodeExposureHa
     taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
     eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
     logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-    serializer: IResource<void, Promise<Serializer>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+    serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
 }, any, {
     title: string;
     description: string;
@@ -2351,8 +3022,8 @@ interface InputFile<TStream = unknown> extends InputFileMeta {
     }>;
 }
 /** Client-side sentinel to declare file presence in an input structure. */
-interface EjsonFileSentinel {
-    $ejson: "File";
+interface RunnerFileSentinel {
+    $runnerFile: "File";
     id: string;
     meta: InputFileMeta;
 }
@@ -2361,7 +3032,7 @@ interface NodeFileSource {
     stream?: Readable;
     buffer?: Buffer;
 }
-declare function createNodeFile(meta: InputFileMeta, source: NodeFileSource, id?: string): EjsonFileSentinel & {
+declare function createNodeFile(meta: InputFileMeta, source: NodeFileSource, id?: string): RunnerFileSentinel & {
     _node: NodeFileSource;
 };
 
@@ -2378,6 +3049,1386 @@ declare function writeInputFileToPath(file: InputFile<Readable>, targetPath: str
     bytesWritten: number;
 }>;
 
+declare const ExecutionStatus: {
+    readonly Pending: "pending";
+    readonly Running: "running";
+    readonly Retrying: "retrying";
+    readonly Sleeping: "sleeping";
+    readonly Completed: "completed";
+    readonly CompensationFailed: "compensation_failed";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+type ExecutionStatus = (typeof ExecutionStatus)[keyof typeof ExecutionStatus];
+interface Execution<TInput = unknown, TResult = unknown> {
+    id: string;
+    taskId: string;
+    input: TInput | undefined;
+    status: ExecutionStatus;
+    result?: TResult;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    /** Optional cancellation metadata (cooperative cancellation). */
+    cancelledAt?: Date;
+    cancelRequestedAt?: Date;
+    attempt: number;
+    maxAttempts: number;
+    timeout?: number;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+interface StepResult<T = unknown> {
+    executionId: string;
+    stepId: string;
+    result: T;
+    completedAt: Date;
+}
+declare const TimerType: {
+    readonly Sleep: "sleep";
+    readonly Timeout: "timeout";
+    readonly Scheduled: "scheduled";
+    readonly Cron: "cron";
+    readonly Retry: "retry";
+    readonly SignalTimeout: "signal_timeout";
+};
+type TimerType = (typeof TimerType)[keyof typeof TimerType];
+declare const TimerStatus: {
+    readonly Pending: "pending";
+    readonly Fired: "fired";
+};
+type TimerStatus = (typeof TimerStatus)[keyof typeof TimerStatus];
+interface Timer {
+    id: string;
+    executionId?: string;
+    stepId?: string;
+    scheduleId?: string;
+    taskId?: string;
+    input?: unknown;
+    type: TimerType;
+    fireAt: Date;
+    status: TimerStatus;
+}
+declare const ScheduleType: {
+    readonly Cron: "cron";
+    readonly Interval: "interval";
+};
+type ScheduleType = (typeof ScheduleType)[keyof typeof ScheduleType];
+declare const ScheduleStatus: {
+    readonly Active: "active";
+    readonly Paused: "paused";
+};
+type ScheduleStatus = (typeof ScheduleStatus)[keyof typeof ScheduleStatus];
+interface Schedule<TInput = unknown> {
+    id: string;
+    taskId: string;
+    type: ScheduleType;
+    pattern: string;
+    input: TInput | undefined;
+    status: ScheduleStatus;
+    lastRun?: Date;
+    nextRun?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+type DurableSignalId<TPayload = unknown> = IEventDefinition<TPayload>;
+interface DurableStepId<TResult = unknown> {
+    id: string;
+    /**
+     * Phantom field used only for type inference. Not present at runtime.
+     * The result type is carried through the object type.
+     */
+    readonly __result?: TResult;
+}
+declare function createDurableStepId<TResult>(id: string): DurableStepId<TResult>;
+
+declare const DurableAuditEntryKind: {
+    readonly ExecutionStatusChanged: "execution_status_changed";
+    readonly StepCompleted: "step_completed";
+    readonly SleepScheduled: "sleep_scheduled";
+    readonly SleepCompleted: "sleep_completed";
+    readonly SignalWaiting: "signal_waiting";
+    readonly SignalDelivered: "signal_delivered";
+    readonly SignalTimedOut: "signal_timed_out";
+    readonly EmitPublished: "emit_published";
+    readonly Note: "note";
+};
+type DurableAuditEntryKind = (typeof DurableAuditEntryKind)[keyof typeof DurableAuditEntryKind];
+interface DurableAuditEntryBase {
+    id: string;
+    executionId: string;
+    at: Date;
+    kind: DurableAuditEntryKind;
+    attempt: number;
+    taskId?: string;
+}
+type DurableAuditEntry = (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.ExecutionStatusChanged;
+    from: ExecutionStatus | null;
+    to: ExecutionStatus;
+    reason?: string;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.StepCompleted;
+    stepId: string;
+    durationMs: number;
+    isInternal: boolean;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.SleepScheduled;
+    stepId: string;
+    timerId: string;
+    durationMs: number;
+    fireAt: Date;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.SleepCompleted;
+    stepId: string;
+    timerId: string;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.SignalWaiting;
+    stepId: string;
+    signalId: string;
+    timeoutMs?: number;
+    timeoutAtMs?: number;
+    timerId?: string;
+    reason?: "initial" | "timeout_armed";
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.SignalDelivered;
+    stepId: string;
+    signalId: string;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.SignalTimedOut;
+    stepId: string;
+    signalId: string;
+    timerId: string;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.EmitPublished;
+    stepId: string;
+    eventId: string;
+}) | (DurableAuditEntryBase & {
+    kind: typeof DurableAuditEntryKind.Note;
+    message: string;
+    meta?: Record<string, unknown>;
+});
+/**
+ * Input type for appendAuditEntry - omits auto-generated fields (id, at).
+ * Preserves the discriminated union for proper type checking at call sites.
+ * executionId and attempt are required for service-level entries but filled by context.
+ */
+type DurableAuditEntryInput = {
+    kind: typeof DurableAuditEntryKind.ExecutionStatusChanged;
+    executionId: string;
+    attempt: number;
+    from: ExecutionStatus | null;
+    to: ExecutionStatus;
+    reason?: string;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.StepCompleted;
+    stepId: string;
+    durationMs: number;
+    isInternal: boolean;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.SleepScheduled;
+    stepId: string;
+    timerId: string;
+    durationMs: number;
+    fireAt: Date;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.SleepCompleted;
+    executionId: string;
+    attempt: number;
+    stepId: string;
+    timerId: string;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.SignalWaiting;
+    stepId: string;
+    signalId: string;
+    timeoutMs?: number;
+    timeoutAtMs?: number;
+    timerId?: string;
+    reason?: "initial" | "timeout_armed";
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.SignalDelivered;
+    executionId: string;
+    attempt: number;
+    stepId: string;
+    signalId: string;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.SignalTimedOut;
+    executionId: string;
+    attempt: number;
+    stepId: string;
+    signalId: string;
+    timerId: string;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.EmitPublished;
+    stepId: string;
+    eventId: string;
+    taskId?: string;
+} | {
+    kind: typeof DurableAuditEntryKind.Note;
+    message: string;
+    meta?: Record<string, unknown>;
+    taskId?: string;
+};
+interface DurableAuditEmitter {
+    emit(entry: DurableAuditEntry): Promise<void>;
+}
+declare function isDurableInternalStepId(stepId: string): boolean;
+declare function createDurableAuditEntryId(atMs?: number): string;
+
+interface ListExecutionsOptions {
+    status?: ExecutionStatus[];
+    taskId?: string;
+    limit?: number;
+    offset?: number;
+}
+interface IDurableStore {
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    /**
+     * Optional execution-level idempotency mapping.
+     * If supported, allows `startExecution(..., { idempotencyKey })` to dedupe workflow starts.
+     */
+    getExecutionIdByIdempotencyKey?(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey?(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    listExecutions?(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults?(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry?(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries?(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    retryRollback?(executionId: string): Promise<void>;
+    skipStep?(executionId: string, stepId: string): Promise<void>;
+    forceFail?(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult?(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    /**
+     * Atomically claim a timer for processing. Returns true if claimed, false if already claimed.
+     * Used for distributed timer coordination to ensure only one worker processes each timer.
+     * @param timerId The ID of the timer to claim
+     * @param workerId A unique identifier for the worker claiming the timer
+     * @param ttlMs Time-to-live in milliseconds for the claim (in case worker dies)
+     */
+    claimTimer?(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    deleteTimer(timerId: string): Promise<void>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    listStuckExecutions?(): Promise<Execution[]>;
+    init?(): Promise<void>;
+    dispose?(): Promise<void>;
+    acquireLock?(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock?(resource: string, lockId: string): Promise<void>;
+}
+
+interface QueueMessage<T = unknown> {
+    id: string;
+    type: "execute" | "resume" | "schedule";
+    payload: T;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: Date;
+}
+type MessageHandler<T = unknown> = (message: QueueMessage<T>) => Promise<void>;
+interface IDurableQueue {
+    enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
+    consume<T>(handler: MessageHandler<T>): Promise<void>;
+    ack(messageId: string): Promise<void>;
+    nack(messageId: string, requeue?: boolean): Promise<void>;
+    init?(): Promise<void>;
+    dispose?(): Promise<void>;
+}
+
+interface BusEvent {
+    type: string;
+    payload: unknown;
+    timestamp: Date;
+}
+type BusEventHandler = (event: BusEvent) => Promise<void>;
+interface IEventBus {
+    publish(channel: string, event: BusEvent): Promise<void>;
+    subscribe(channel: string, handler: BusEventHandler): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    init?(): Promise<void>;
+    dispose?(): Promise<void>;
+}
+
+interface StepOptions {
+    retries?: number;
+    timeout?: number;
+}
+/**
+ * Options for sleep operations.
+ * Use `stepId` to provide a stable identifier that survives code refactoring.
+ */
+interface SleepOptions {
+    /** Explicit step ID for replay stability. If not provided, an auto-indexed ID is used. */
+    stepId?: string;
+}
+/**
+ * Options for waitForSignal operations.
+ */
+interface SignalOptions {
+    /** Timeout in milliseconds. If provided, returns a discriminated union with kind. */
+    timeoutMs?: number;
+    /** Explicit step ID for replay stability. If not provided, an auto-indexed ID is used. */
+    stepId?: string;
+}
+/**
+ * Options for emit operations.
+ */
+interface EmitOptions {
+    /** Explicit step ID for replay stability. If not provided, an auto-indexed ID is used. */
+    stepId?: string;
+}
+interface IStepBuilder<T> extends PromiseLike<T> {
+    up(fn: () => Promise<T>): this;
+    down(fn: (result: T) => Promise<void>): this;
+}
+interface IDurableContext {
+    readonly executionId: string;
+    readonly attempt: number;
+    step<T>(stepId: string): IStepBuilder<T>;
+    step<T>(stepId: DurableStepId<T>): IStepBuilder<T>;
+    step<T>(stepId: string, fn: () => Promise<T>): Promise<T>;
+    step<T>(stepId: DurableStepId<T>, fn: () => Promise<T>): Promise<T>;
+    step<T>(stepId: string, options: StepOptions, fn: () => Promise<T>): Promise<T>;
+    step<T>(stepId: DurableStepId<T>, options: StepOptions, fn: () => Promise<T>): Promise<T>;
+    sleep(durationMs: number, options?: SleepOptions): Promise<void>;
+    /**
+     * Suspend until an external signal is delivered via DurableService.signal().
+     * The signal is memoized as a durable step under `__signal:<signalId>[:index]`.
+     * Use options.stepId to provide a stable identifier for replay safety.
+     */
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>): Promise<TPayload>;
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>, options: SignalOptions & {
+        timeoutMs: number;
+    }): Promise<{
+        kind: "signal";
+        payload: TPayload;
+    } | {
+        kind: "timeout";
+    }>;
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>, options: SignalOptions): Promise<TPayload>;
+    emit<TPayload>(event: IEventDefinition<TPayload>, payload: TPayload, options?: EmitOptions): Promise<void>;
+    /**
+     * Append a custom audit entry for observability and debugging.
+     * This is a no-op if audit is disabled or the store does not support it.
+     */
+    note(message: string, meta?: Record<string, unknown>): Promise<void>;
+    rollback(): Promise<void>;
+}
+/**
+ * Internal control-flow signal used to suspend a durable execution without failing it.
+ *
+ * `DurableContext` throws this error to indicate "pause here and resume later":
+ * - `"sleep"`: durable sleep timer was scheduled
+ * - `"yield"`: waiting for a signal (or signal-timeout timer) to complete
+ *
+ * `ExecutionManager` treats this as a normal suspension and will not mark the execution
+ * as failed; instead it schedules a resume via timers/queue depending on configuration.
+ */
+declare class SuspensionSignal extends Error {
+    readonly reason: "sleep" | "yield" | "timeout";
+    constructor(reason: "sleep" | "yield" | "timeout");
+}
+
+type DurableTask<TInput = unknown, TResult = unknown> = ITask<TInput, Promise<TResult>, any>;
+interface ITaskExecutor {
+    run<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput): Promise<TResult>;
+}
+interface ScheduleConfig<TInput = unknown> {
+    id: string;
+    task: DurableTask<TInput, unknown>;
+    cron?: string;
+    interval?: number;
+    input: TInput;
+}
+interface DurableServiceConfig {
+    store: IDurableStore;
+    queue?: IDurableQueue;
+    eventBus?: IEventBus;
+    taskExecutor?: ITaskExecutor;
+    determinism?: {
+        /**
+         * Internal step IDs for `sleep()`/`emit()`/`waitForSignal()` default to call-order based IDs.
+         * In production this can be a replay/versioning footgun when refactors change call order.
+         *
+         * - "allow" (default): do nothing
+         * - "warn": emit a warning on first implicit internal step per kind
+         * - "error": throw when an implicit internal step id would be used
+         */
+        implicitInternalStepIds?: "allow" | "warn" | "error";
+    };
+    /**
+     * Unique identifier for this worker instance.
+     * Used for distributed timer coordination to ensure only one worker processes each timer.
+     * If not provided, a random UUID is generated.
+     */
+    workerId?: string;
+    /**
+     * Runs a callback with the given durable context available.
+     * In Runner environments this is typically implemented via AsyncLocalStorage
+     * so tasks can call `durable.use()`.
+     */
+    contextProvider?: <R>(context: IDurableContext, fn: () => Promise<R> | R) => Promise<R> | R;
+    /**
+     * Resolves tasks by id for resuming/recovering executions.
+     * Useful in Runner environments where tasks are registered in the Store registry.
+     */
+    taskResolver?: (taskId: string) => DurableTask<any, any> | undefined;
+    audit?: {
+        enabled?: boolean;
+        emitter?: DurableAuditEmitter;
+    };
+    polling?: {
+        enabled?: boolean;
+        interval?: number;
+        /** Time-to-live for timer claims in milliseconds. Default: 30000. */
+        claimTtlMs?: number;
+    };
+    execution?: {
+        maxAttempts?: number;
+        timeout?: number;
+        /**
+         * When a queue is configured, `startExecution()` persists the execution and then enqueues it.
+         * If enqueue fails (eg. broker outage), the execution would otherwise remain "pending" forever.
+         *
+         * This delay arms a small store-backed timer as a failsafe so workers can retry resuming it
+         * via the poller. Default: 10000 (10s). Set to 0 to disable.
+         */
+        kickoffFailsafeDelayMs?: number;
+    };
+    schedules?: ScheduleConfig[];
+    tasks?: Array<DurableTask<any, any>>;
+}
+interface ExecuteOptions {
+    timeout?: number;
+    priority?: number;
+    waitPollIntervalMs?: number;
+    /**
+     * Optional workflow-level idempotency key.
+     * When supported by the store, multiple concurrent callers using the same key will receive the same executionId.
+     */
+    idempotencyKey?: string;
+}
+interface ScheduleOptions {
+    id?: string;
+    at?: Date;
+    delay?: number;
+    cron?: string;
+    interval?: number;
+}
+interface IDurableService {
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    /**
+     * Request cancellation for an execution.
+     * Cancellation is cooperative: it marks the execution as cancelled and unblocks waiters,
+     * but cannot preempt arbitrary in-process async work.
+     */
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    wait<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    /**
+     * A stricter alternative to `execute()` that rejects tasks whose result type
+     * includes `undefined` (including `void`, `unknown`, and `any`).
+     *
+     * This mirrors the runtime contract where `wait()`/`execute()` treat
+     * "completed without result" as an error.
+     */
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    /**
+     * Idempotently create (or update) a recurring schedule (cron/interval) with a stable id.
+     * Safe to call concurrently from multiple processes.
+     */
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    recover(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+    pauseSchedule(scheduleId: string): Promise<void>;
+    resumeSchedule(scheduleId: string): Promise<void>;
+    getSchedule(scheduleId: string): Promise<Schedule | null>;
+    listSchedules(): Promise<Schedule[]>;
+    updateSchedule(scheduleId: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    removeSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Deliver a signal payload to a waiting workflow execution and resume it.
+     */
+    signal<TPayload>(executionId: string, signal: IEventDefinition<TPayload>, payload: TPayload): Promise<void>;
+}
+interface IDurableExecutionProcessor {
+    processExecution(executionId: string): Promise<void>;
+}
+
+interface DurableResourceConfig {
+    worker?: boolean;
+}
+interface IDurableResource extends Pick<IDurableService, "startExecution" | "cancelExecution" | "wait" | "execute" | "executeStrict" | "schedule" | "ensureSchedule" | "pauseSchedule" | "resumeSchedule" | "getSchedule" | "listSchedules" | "updateSchedule" | "removeSchedule" | "recover" | "signal"> {
+    /**
+     * Reads the durable context for the currently running workflow execution.
+     * Throws if called outside of a durable execution.
+     */
+    use(): IDurableContext;
+}
+/**
+ * A Runner-facing wrapper around `DurableService` that exposes a per-instance
+ * context store and the public durable API (`execute`, `signal`, `wait`, etc.).
+ *
+ * This enables tasks to depend on a specific durable instance and call
+ * `durable.use()` to access the per-execution durable context.
+ */
+declare class DurableResource$1 implements IDurableResource {
+    readonly service: IDurableService;
+    private readonly contextStorage;
+    constructor(service: IDurableService, contextStorage: AsyncLocalStorage<IDurableContext>);
+    use(): IDurableContext;
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    wait<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    pauseSchedule(scheduleId: string): Promise<void>;
+    resumeSchedule(scheduleId: string): Promise<void>;
+    getSchedule(scheduleId: string): Promise<Schedule | null>;
+    listSchedules(): Promise<Schedule[]>;
+    updateSchedule(scheduleId: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    removeSchedule(scheduleId: string): Promise<void>;
+    recover(): Promise<void>;
+    signal<TPayload>(executionId: string, signal: IEventDefinition<TPayload>, payload: TPayload): Promise<void>;
+}
+
+declare const durableEvents: {
+    readonly audit: {
+        readonly appended: IEvent<{
+            entry: DurableAuditEntry;
+        }>;
+    };
+    readonly execution: {
+        readonly statusChanged: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.ExecutionStatusChanged;
+            from: ExecutionStatus | null;
+            to: ExecutionStatus;
+            reason?: string;
+        }>;
+    };
+    readonly step: {
+        readonly completed: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.StepCompleted;
+            stepId: string;
+            durationMs: number;
+            isInternal: boolean;
+        }>;
+    };
+    readonly sleep: {
+        readonly scheduled: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SleepScheduled;
+            stepId: string;
+            timerId: string;
+            durationMs: number;
+            fireAt: Date;
+        }>;
+        readonly completed: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SleepCompleted;
+            stepId: string;
+            timerId: string;
+        }>;
+    };
+    readonly signal: {
+        readonly waiting: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalWaiting;
+            stepId: string;
+            signalId: string;
+            timeoutMs?: number;
+            timeoutAtMs?: number;
+            timerId?: string;
+            reason?: "initial" | "timeout_armed";
+        }>;
+        readonly delivered: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalDelivered;
+            stepId: string;
+            signalId: string;
+        }>;
+        readonly timedOut: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.SignalTimedOut;
+            stepId: string;
+            signalId: string;
+            timerId: string;
+        }>;
+    };
+    readonly emit: {
+        readonly published: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.EmitPublished;
+            stepId: string;
+            eventId: string;
+        }>;
+    };
+    readonly note: {
+        readonly created: IEvent<DurableAuditEntryBase & {
+            kind: typeof DurableAuditEntryKind.Note;
+            message: string;
+            meta?: Record<string, unknown>;
+        }>;
+    };
+};
+declare const durableEventsArray: IEvent<any>[];
+
+declare function createDurableRunnerAuditEmitter(params: {
+    eventManager: EventManager;
+    source?: string;
+}): DurableAuditEmitter;
+
+declare class NoopEventBus implements IEventBus {
+    publish(_channel: string, _event: BusEvent): Promise<void>;
+    subscribe(_channel: string, _handler: BusEventHandler): Promise<void>;
+    unsubscribe(_channel: string): Promise<void>;
+}
+
+/**
+ * In-memory durable task registry.
+ *
+ * Durable executions persist only a `taskId` in the store, so the runtime needs a way
+ * to resolve `taskId -> DurableTask` when resuming. This registry holds tasks that
+ * were registered on the current process and optionally delegates to an external
+ * resolver for tasks defined elsewhere (useful for modular apps).
+ */
+declare class TaskRegistry {
+    private readonly externalResolver?;
+    private readonly tasks;
+    constructor(externalResolver?: ((taskId: string) => DurableTask<any, any> | undefined) | undefined);
+    register<TInput, TResult>(task: DurableTask<TInput, TResult>): void;
+    find(taskId: string): DurableTask<any, any> | undefined;
+}
+
+interface AuditConfig {
+    /**
+     * When enabled, attempts to persist audit entries to the store (if supported).
+     * This is separate from event emission via `emitter`.
+     */
+    enabled?: boolean;
+    /**
+     * Optional emitter for streaming audit entries (e.g. Runner events, logging, mirroring).
+     * Emissions must be best-effort and never affect workflow correctness.
+     */
+    emitter?: DurableAuditEmitter;
+}
+/**
+ * Durable audit trail sink.
+ *
+ * Used across the durable subsystem (service/managers/context) to record lifecycle
+ * events in a best-effort way. Persistence and emission are explicitly non-critical:
+ * failures must never affect workflow correctness (the store remains the source of truth).
+ */
+declare class AuditLogger {
+    private readonly config;
+    private readonly store;
+    constructor(config: AuditConfig, store: IDurableStore);
+    log(params: DurableAuditEntryInput & {
+        at?: Date;
+    }): Promise<void>;
+}
+
+interface WaitConfig {
+    defaultTimeout?: number;
+    defaultPollIntervalMs?: number;
+}
+/**
+ * Waits for an execution to reach a terminal state and returns/throws accordingly.
+ *
+ * Strategy:
+ * - if an event bus is configured, subscribe to `execution:<executionId>` for low-latency completion
+ * - otherwise (or on bus issues) fall back to polling the store
+ *
+ * The durable store remains the source of truth; this manager is purely a convenience layer
+ * for callers that want `await durable.wait(...)` / `await durable.execute(...)`.
+ */
+declare class WaitManager {
+    private readonly store;
+    private readonly eventBus?;
+    private readonly config?;
+    constructor(store: IDurableStore, eventBus?: IEventBus | undefined, config?: WaitConfig | undefined);
+    waitForResult<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+}
+
+/**
+ * Creates and maintains durable schedules.
+ *
+ * A schedule is persisted in the store and translated into durable timers that
+ * `PollingManager` will later process to kick off executions. This keeps scheduling
+ * crash-safe and horizontally scalable: schedules aren't owned by in-memory timers.
+ */
+declare class ScheduleManager {
+    private readonly store;
+    private readonly taskRegistry;
+    constructor(store: IDurableStore, taskRegistry: TaskRegistry);
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    reschedule(schedule: Schedule, options?: {
+        lastRunAt?: Date;
+    }): Promise<void>;
+    pause(id: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    get(id: string): Promise<Schedule | null>;
+    list(): Promise<Schedule[]>;
+    update(id: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+
+interface ExecutionManagerConfig {
+    store: IDurableStore;
+    queue?: IDurableQueue;
+    eventBus?: IEventBus;
+    taskExecutor?: ITaskExecutor;
+    contextProvider?: DurableServiceConfig["contextProvider"];
+    audit?: DurableServiceConfig["audit"];
+    determinism?: DurableServiceConfig["determinism"];
+    execution?: {
+        maxAttempts?: number;
+        timeout?: number;
+        kickoffFailsafeDelayMs?: number;
+    };
+}
+/**
+ * Runs durable executions (the "workflow engine" for attempts).
+ *
+ * Responsibilities:
+ * - persist new executions (including optional idempotency keys)
+ * - enqueue work (queue mode) or run directly (embedded mode)
+ * - execute a workflow attempt via `taskExecutor.run(...)`
+ * - inject a per-attempt `DurableContext` (via `contextProvider` / ALS wrapper)
+ * - interpret `SuspensionSignal` as "pause + reschedule" rather than failure
+ * - update execution status/result/error and notify waiters (`WaitManager`)
+ */
+declare class ExecutionManager {
+    private readonly config;
+    private readonly taskRegistry;
+    private readonly auditLogger;
+    private readonly waitManager;
+    constructor(config: ExecutionManagerConfig, taskRegistry: TaskRegistry, auditLogger: AuditLogger, waitManager: WaitManager);
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    processExecution(executionId: string): Promise<void>;
+    kickoffExecution(executionId: string): Promise<void>;
+    notifyExecutionFinished(execution: Execution): Promise<void>;
+    private runExecutionAttempt;
+}
+
+interface PollingConfig {
+    enabled?: boolean;
+    interval?: number;
+    claimTtlMs?: number;
+}
+interface PollingManagerCallbacks {
+    processExecution: (executionId: string) => Promise<void>;
+    kickoffExecution: (executionId: string) => Promise<void>;
+}
+/**
+ * Timer/tick driver for durable workflows.
+ *
+ * The durable store is the source of truth, but time needs an active driver:
+ * `PollingManager` periodically scans ready timers and performs the appropriate action:
+ *
+ * - complete `sleep()` steps by marking their step result as completed
+ * - resume executions after signal timeouts / scheduled kickoffs / retries
+ * - coordinate multi-worker polling via optional `store.claimTimer(...)`
+ *
+ * In production topologies you typically enable polling on worker nodes only.
+ */
+declare class PollingManager {
+    private readonly workerId;
+    private readonly config;
+    private readonly store;
+    private readonly queue;
+    private readonly maxAttempts;
+    private readonly defaultTimeout;
+    private readonly taskRegistry;
+    private readonly auditLogger;
+    private readonly scheduleManager;
+    private readonly callbacks;
+    private isRunning;
+    private pollingTimer;
+    private pollingWake;
+    constructor(workerId: string, config: PollingConfig, store: IDurableStore, queue: IDurableQueue | undefined, maxAttempts: number, defaultTimeout: number | undefined, taskRegistry: TaskRegistry, auditLogger: AuditLogger, scheduleManager: ScheduleManager, callbacks: PollingManagerCallbacks);
+    start(): void;
+    stop(): Promise<void>;
+    private poll;
+    /** @internal - public for testing */
+    handleTimer(timer: Timer): Promise<void>;
+}
+
+/**
+ * Error thrown to consumers waiting on an execution (`DurableService.wait/execute*`).
+ *
+ * Distinguishes durable execution failures/timeouts/cancellations from ordinary
+ * task errors by carrying execution metadata and a (serialized) cause payload.
+ * `WaitManager` is the primary producer of this error.
+ */
+declare class DurableExecutionError extends Error {
+    readonly executionId: string;
+    readonly taskId: string;
+    readonly attempt: number;
+    readonly causeInfo?: {
+        message: string;
+        stack?: string;
+    } | undefined;
+    constructor(message: string, executionId: string, taskId: string, attempt: number, causeInfo?: {
+        message: string;
+        stack?: string;
+    } | undefined);
+}
+
+/**
+ * High-level facade for the Durable Workflows subsystem.
+ *
+ * `DurableService` glues together the durable backends (store/queue/event bus) and
+ * the specialized managers that implement durable semantics:
+ *
+ * - `ExecutionManager` runs workflow attempts and injects `DurableContext`
+ * - `SignalHandler` delivers external signals to waiting steps
+ * - `WaitManager` waits for results (event-bus first, polling fallback)
+ * - `ScheduleManager` creates/updates schedules and their timers
+ * - `PollingManager` drives timers (sleep, retries, signal timeouts, schedules)
+ * - `AuditLogger` emits/persists an audit trail (best-effort)
+ *
+ * `DurableResource` wraps this service for Runner integration and provides
+ * `durable.use()` to read the per-execution `DurableContext`.
+ */
+declare class DurableService implements IDurableService {
+    private readonly config;
+    private readonly taskRegistry;
+    private readonly auditLogger;
+    private readonly waitManager;
+    private readonly scheduleManager;
+    private readonly signalHandler;
+    private readonly executionManager;
+    private readonly pollingManager;
+    /** Unique worker ID for distributed timer coordination */
+    private readonly workerId;
+    constructor(config: DurableServiceConfig);
+    registerTask<TInput, TResult>(task: DurableTask<TInput, TResult>): void;
+    findTask(taskId: string): DurableTask<any, any> | undefined;
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    wait<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    recover(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+    pauseSchedule(id: string): Promise<void>;
+    resumeSchedule(id: string): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    listSchedules(): Promise<Schedule[]>;
+    updateSchedule(id: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    removeSchedule(id: string): Promise<void>;
+    signal<TPayload>(executionId: string, signal: IEventDefinition<TPayload>, payload: TPayload): Promise<void>;
+    processExecution(executionId: string): Promise<void>;
+    getEventBus(): NoopEventBus;
+    /** @internal - exposed for unit testing */
+    get _pollingManager(): PollingManager;
+    /** @internal - exposed for unit testing */
+    get _executionManager(): ExecutionManager;
+    /** @internal - exposed for unit testing (delegates to pollingManager) */
+    handleTimer(timer: Timer): Promise<void>;
+}
+declare function initDurableService(config: DurableServiceConfig): Promise<DurableService>;
+declare function disposeDurableService(service: IDurableService, config: DurableServiceConfig): Promise<void>;
+
+type DurableResourceRuntimeConfig = Omit<DurableServiceConfig, "taskExecutor" | "tasks" | "taskResolver" | "contextProvider"> & {
+    /**
+     * Starts an embedded worker (queue consumer) in this process.
+     * Has effect only when `queue` is configured.
+     */
+    worker?: boolean;
+};
+/**
+ * A reusable durable resource template.
+ *
+ * Usage:
+ * - `const durable = durableResource.fork("app.durable");`
+ * - Register it via `durable.with({ store, queue, eventBus, ... })`
+ */
+declare const durableResource: IResource<DurableResourceRuntimeConfig, Promise<DurableResource$1>, {
+    taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+    eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+    runnerStore: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+}, any, IResourceMeta, TagType[], ResourceMiddlewareAttachmentType[]>;
+
+type ImplicitInternalStepIdsPolicy = "allow" | "warn" | "error";
+
+/**
+ * Per-execution workflow toolkit used by durable tasks.
+ *
+ * `DurableContext` is created by `ExecutionManager` for each execution attempt and
+ * made available to user code via `DurableResource.use()` (AsyncLocalStorage).
+ *
+ * It provides deterministic "save points" (`step()`), durable suspension primitives
+ * (`sleep()`, `waitForSignal()`), and best-effort side-channel notifications (`emit()`).
+ * The durable store is the source of truth; this class is intentionally thin state
+ * around indexes/guards to keep a single in-memory attempt deterministic.
+ */
+declare class DurableContext implements IDurableContext {
+    private readonly store;
+    private readonly bus;
+    readonly executionId: string;
+    readonly attempt: number;
+    private readonly sleepIndexRef;
+    private readonly signalIndexes;
+    private readonly emitIndexes;
+    private noteIndex;
+    private readonly implicitInternalStepIdsWarned;
+    private readonly seenStepIds;
+    private readonly compensations;
+    private readonly audit;
+    private readonly determinism;
+    private readonly auditEnabled;
+    private readonly auditEmitter;
+    private readonly implicitInternalStepIdsPolicy;
+    constructor(store: IDurableStore, bus: IEventBus, executionId: string, attempt: number, options?: {
+        auditEnabled?: boolean;
+        auditEmitter?: DurableAuditEmitter;
+        implicitInternalStepIds?: ImplicitInternalStepIdsPolicy;
+    });
+    private assertNotCancelled;
+    private getStepId;
+    private internalStep;
+    step<T>(stepId: string): IStepBuilder<T>;
+    step<T>(stepId: DurableStepId<T>): IStepBuilder<T>;
+    step<T>(stepId: string | DurableStepId<T>, fn: () => Promise<T>): Promise<T>;
+    step<T>(stepId: string | DurableStepId<T>, options: StepOptions, fn: () => Promise<T>): Promise<T>;
+    _executeStep<T>(stepId: string, options: StepOptions, upFn: () => Promise<T>, downFn?: (result: T) => Promise<void>): Promise<T>;
+    rollback(): Promise<void>;
+    sleep(durationMs: number, options?: SleepOptions): Promise<void>;
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>): Promise<TPayload>;
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>, options: SignalOptions & {
+        timeoutMs: number;
+    }): Promise<{
+        kind: "signal";
+        payload: TPayload;
+    } | {
+        kind: "timeout";
+    }>;
+    waitForSignal<TPayload>(signal: IEventDefinition<TPayload>, options: SignalOptions): Promise<TPayload>;
+    emit<TPayload>(event: IEventDefinition<TPayload>, payload: TPayload, options?: EmitOptions): Promise<void>;
+    note(message: string, meta?: Record<string, unknown>): Promise<void>;
+}
+
+/**
+ * Fluent helper for building a durable step.
+ *
+ * This is the ergonomic layer behind `ctx.step("id")`:
+ * - `up()` defines the memoized computation
+ * - `down()` registers a compensation to be invoked by `ctx.rollback()`
+ *
+ * It is `PromiseLike`, so users can `await ctx.step("x").up(...).down(...)`.
+ */
+declare class StepBuilder<T> implements IStepBuilder<T> {
+    private readonly context;
+    private readonly stepId;
+    private readonly options;
+    private upFn?;
+    private downFn?;
+    constructor(context: DurableContext, stepId: string, options?: StepOptions);
+    up(fn: () => Promise<T>): this;
+    down(fn: (result: T) => Promise<void>): this;
+    private execute;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+
+/**
+ * Administrative / operator API for durable workflows.
+ *
+ * This class is intentionally store-backed and side-effect free with respect to
+ * "running" workflows: it reads execution details and, when supported by the store,
+ * can perform operator actions (retry rollback, skip a step, force fail, patch state).
+ *
+ * Used by dashboards / CLIs / tooling to inspect and recover executions.
+ */
+declare class DurableOperator {
+    private readonly store;
+    constructor(store: IDurableStore);
+    listExecutions(options?: ListExecutionsOptions): Promise<Execution[]>;
+    getExecutionDetail(executionId: string): Promise<{
+        execution: Execution | null;
+        steps: StepResult[];
+        audit: DurableAuditEntry[];
+    }>;
+    /**
+     * Resets an execution from `compensation_failed` (or other states) to `pending`.
+     * This effectively retries the workflow from the last memoized step.
+     */
+    retryRollback(executionId: string): Promise<void>;
+    /**
+     * Manually marks a step as completed with a specific result.
+     * Useful for skipping broken steps or providing a manual fix.
+     */
+    skipStep(executionId: string, stepId: string): Promise<void>;
+    /**
+     * Forces an execution to the `failed` state.
+     */
+    forceFail(executionId: string, reason: string): Promise<void>;
+    /**
+     * Manually patches the result of a step.
+     * Useful when a step failed to save its result but the side effect occurred.
+     */
+    editState(executionId: string, stepId: string, newState: unknown): Promise<void>;
+    /**
+     * Lists all executions that require manual intervention.
+     */
+    listStuckExecutions(): Promise<Execution[]>;
+}
+
+/**
+ * Durable queue consumer (worker process role).
+ *
+ * The worker listens to the durable queue and turns queue messages into
+ * `processExecution(executionId)` calls on the service layer (`ExecutionManager`
+ * behind `IDurableExecutionProcessor`). This is how "resume" work is distributed
+ * horizontally: the store is the source of truth, the queue provides delivery.
+ */
+declare class DurableWorker {
+    private readonly service;
+    private readonly queue;
+    constructor(service: IDurableExecutionProcessor, queue: IDurableQueue);
+    start(): Promise<void>;
+    private handleMessage;
+    private extractExecutionId;
+}
+declare function initDurableWorker(service: IDurableExecutionProcessor, queue: IDurableQueue): Promise<DurableWorker>;
+
+type DashboardMiddlewareOptions = {
+    /**
+     * Override where the dashboard UI is served from.
+     * Useful for tests or custom deployments.
+     */
+    uiDistPath?: string;
+    /**
+     * Authorization hook for operator actions (retry/skip/force/edit).
+     * Return true to allow, false to deny.
+     */
+    operatorAuth?: (req: Request) => boolean | Promise<boolean>;
+    /**
+     * Opt out of operator auth checks (not recommended).
+     */
+    dangerouslyAllowUnauthenticatedOperator?: boolean;
+};
+declare function createDashboardMiddleware(_service: IDurableService, operator: DurableOperator, options?: DashboardMiddlewareOptions): Router;
+
+declare class MemoryStore implements IDurableStore {
+    private executions;
+    private executionIdByIdempotencyKey;
+    private stepResults;
+    private auditEntries;
+    private timers;
+    private schedules;
+    private locks;
+    private getIdempotencyMapKey;
+    getExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    listStuckExecutions(): Promise<Execution[]>;
+    listExecutions(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    retryRollback(executionId: string): Promise<void>;
+    skipStep(executionId: string, stepId: string): Promise<void>;
+    forceFail(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    deleteTimer(timerId: string): Promise<void>;
+    claimTimer(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock(resource: string, lockId: string): Promise<void>;
+}
+
+interface RedisPipeline {
+    get(key: string): RedisPipeline;
+    hget(hash: string, key: string): RedisPipeline;
+    exec(): Promise<Array<[unknown, unknown]> | null>;
+}
+interface RedisClient {
+    set(...args: unknown[]): Promise<unknown>;
+    get(...args: unknown[]): Promise<unknown>;
+    scan(...args: unknown[]): Promise<unknown>;
+    sscan(...args: unknown[]): Promise<unknown>;
+    sadd(...args: unknown[]): Promise<unknown>;
+    srem(...args: unknown[]): Promise<unknown>;
+    keys?(...args: unknown[]): Promise<unknown>;
+    pipeline(): RedisPipeline;
+    hset(...args: unknown[]): Promise<unknown>;
+    hget(...args: unknown[]): Promise<unknown>;
+    hdel(...args: unknown[]): Promise<unknown>;
+    hgetall(...args: unknown[]): Promise<unknown>;
+    zadd(...args: unknown[]): Promise<unknown>;
+    zrangebyscore(...args: unknown[]): Promise<unknown>;
+    zrem(...args: unknown[]): Promise<unknown>;
+    eval(...args: unknown[]): Promise<unknown>;
+    quit(...args: unknown[]): Promise<unknown>;
+}
+interface RedisStoreConfig {
+    prefix?: string;
+    redis?: RedisClient | string;
+}
+declare class RedisStore implements IDurableStore {
+    private redis;
+    private prefix;
+    constructor(config: RedisStoreConfig);
+    private k;
+    private encodeKeyPart;
+    getExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    private parseRedisString;
+    private parseScanResponse;
+    private scanKeys;
+    private scanSetMembers;
+    private activeExecutionsKey;
+    private isActiveExecutionStatus;
+    private updateActiveExecutionMembership;
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    listStuckExecutions(): Promise<Execution[]>;
+    retryRollback(executionId: string): Promise<void>;
+    skipStep(executionId: string, stepId: string): Promise<void>;
+    forceFail(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    listExecutions(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    deleteTimer(timerId: string): Promise<void>;
+    claimTimer(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock(resource: string, lockId: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+declare class MemoryQueue implements IDurableQueue {
+    private queue;
+    private handler;
+    private isProcessing;
+    private readonly inFlight;
+    enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
+    consume<T>(handler: MessageHandler<T>): Promise<void>;
+    ack(_messageId: string): Promise<void>;
+    nack(_messageId: string, _requeue?: boolean): Promise<void>;
+    private processNext;
+}
+
+interface RabbitMQQueueConfig {
+    url?: string;
+    queueName?: string;
+    queue?: {
+        name?: string;
+        quorum?: boolean;
+        deadLetter?: string;
+        messageTtl?: number;
+    };
+    prefetch?: number;
+}
+declare class RabbitMQQueue implements IDurableQueue {
+    private connection;
+    private channel;
+    private url;
+    private queueName;
+    private prefetch;
+    private readonly isQuorum;
+    private readonly deadLetterQueue?;
+    private readonly messageTtl?;
+    private messageMap;
+    constructor(config: RabbitMQQueueConfig);
+    init(): Promise<void>;
+    enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
+    consume<T>(handler: MessageHandler<T>): Promise<void>;
+    ack(messageId: string): Promise<void>;
+    nack(messageId: string, requeue?: boolean): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+declare class MemoryEventBus implements IEventBus {
+    private handlers;
+    publish(channel: string, event: BusEvent): Promise<void>;
+    subscribe(channel: string, handler: BusEventHandler): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+}
+
+interface RedisEventBusConfig {
+    prefix?: string;
+    redis?: RedisEventBusClient | string;
+}
+interface RedisEventBusClient {
+    publish(channel: string, payload: string): Promise<unknown>;
+    subscribe(channel: string): Promise<unknown>;
+    unsubscribe(channel: string): Promise<unknown>;
+    on(event: "message", fn: (channel: string, message: string) => void): unknown;
+    quit(): Promise<unknown>;
+    duplicate(): RedisEventBusClient;
+}
+declare class RedisEventBus implements IEventBus {
+    private pub;
+    private sub;
+    private prefix;
+    private readonly channels;
+    private readonly serializer;
+    constructor(config: RedisEventBusConfig);
+    private k;
+    private tryParse;
+    private coerceTimestamp;
+    private toBusEvent;
+    private deserializeEvent;
+    publish(channel: string, event: BusEvent): Promise<void>;
+    subscribe(channel: string, handler: BusEventHandler): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+type DurableResource = ReturnType<typeof durableResource.fork>;
+type DurableResourceRegistration = ReturnType<DurableResource["with"]>;
+interface DurableTestSetup {
+    durable: DurableResource;
+    durableRegistration: DurableResourceRegistration;
+    store: MemoryStore;
+    eventBus: MemoryEventBus;
+    queue?: MemoryQueue;
+}
+interface DurableTestSetupOptions {
+    durableId?: string;
+    store?: MemoryStore;
+    eventBus?: MemoryEventBus;
+    queue?: MemoryQueue;
+    worker?: boolean;
+    pollingIntervalMs?: number;
+    durableConfig?: Partial<DurableResourceRuntimeConfig>;
+}
+declare function createDurableTestSetup(options?: DurableTestSetupOptions): DurableTestSetup;
+declare function waitUntil(predicate: () => boolean | Promise<boolean>, options: {
+    timeoutMs: number;
+    intervalMs: number;
+}): Promise<void>;
+
 declare const globals: {
     resources: {
         httpSmartClientFactory: IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
@@ -2387,15 +4438,15 @@ declare const globals: {
         eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        serializer: IResource<void, Promise<Serializer>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
+        serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
         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[]>;
         queue: IResource<void, Promise<{
             map: Map<string, Queue>;
@@ -2407,12 +4458,37 @@ declare const globals: {
             description: string;
         }, TagType[], ResourceMiddlewareAttachmentType[]>;
         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[]>;
+        rateLimit: IResource<void, Promise<{
+            states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        circuitBreaker: IResource<void, Promise<{
+            statusMap: Map<string, CircuitBreakerStatus>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        temporal: IResource<void, Promise<{
+            debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
+            throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
+        }>, {}, any, any, ITag<{
+            metadata?: Record<string, any>;
+        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
+        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[]>;
     };
     events: {
         readonly ready: IEvent<void>;
@@ -2430,14 +4506,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>;
@@ -2454,6 +4603,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<{
@@ -2469,4 +4619,4 @@ declare const globals: {
 };
 declare function run(root: any, config?: any): Promise<RunResult<any>>;
 
-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 HttpSmartClient, type HttpSmartClientAuthConfig, type HttpSmartClientConfig, 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 MixedHttpClient, type MixedHttpClientAuthConfig, type MixedHttpClientConfig, type NodeExposureConfig, type NodeExposureDependencyMap, type NodeExposureDeps, type NodeExposureHandlers, type NodeExposureHttpConfig, type NodeExposureHttpCorsConfig, 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, createHttpMixedClient, createHttpSmartClient, createNodeFile, createTestResource, debug, debugLevels, defs as definitions, defineEvent as event, getConfig, globals, hasExposureContext, defineHook as hook, isOneOf, levelNormal, levelVerbose, nodeExposure, normalizeError, onAnyOf, defineOverride as override, r, readInputFileToBuffer, 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, useExposureContext, writeInputFileToPath };
+export { type BusEvent, type BusEventHandler, type CommonPayload, type DebugConfig, type DebugFriendlyConfig, type DefaultErrorType, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, type DurableAuditEmitter, type DurableAuditEntry, type DurableAuditEntryBase, type DurableAuditEntryInput, DurableAuditEntryKind, DurableContext, DurableExecutionError, DurableOperator, DurableResource$1 as DurableResource, type DurableResourceConfig, type DurableResourceRuntimeConfig, DurableService, type DurableServiceConfig, type DurableSignalId, type DurableStepId, type DurableTask, type DurableTestSetup, type DurableTestSetupOptions, DurableWorker, type EmitOptions, type ErrorReference, errors as Errors, type EventDeliveryMode, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExecuteOptions, type Execution, type ExecutionJournal, ExecutionStatus, 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 HttpSmartClient, type HttpSmartClientAuthConfig, type HttpSmartClientConfig, type IAsyncContext, type IAsyncContextDefinition, type IAsyncContextMeta, type ICacheInstance, type IDurableContext, type IDurableExecutionProcessor, type IDurableResource, type IDurableService, type IDurableStore, type IErrorDefinition, type IErrorDefinitionFinal, type IErrorHelper, type IErrorMeta, type IEvent, type IEventBus, 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 IStepBuilder, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskExecutor, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type JournalKey, type JsonLimits, type ListExecutionsOptions, type LogLevels, Logger, MemoryEventBus, MemoryQueue, MemoryStore, MiddlewareManager, type MixedHttpClient, type MixedHttpClientAuthConfig, type MixedHttpClientConfig, type NodeExposureConfig, type NodeExposureDependencyMap, type NodeExposureDeps, type NodeExposureHandlers, type NodeExposureHttpConfig, type NodeExposureHttpCorsConfig, NoopEventBus, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, PlatformAdapter, type PrintStrategy, Queue, RabbitMQQueue, RedisEventBus, RedisStore, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, type ResourceForkInfo, type ResourceForkOptions, type ResourceForkRegisterMode, type ResourceInitFn, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, RunnerMode, type Schedule, type ScheduleConfig, type ScheduleOptions, ScheduleStatus, ScheduleType, Semaphore, Serializer, type SerializerOptions, type SignalOptions, type SleepOptions, StepBuilder, type StepOptions, type StepResult, Store, SuspensionSignal, type TagType, type TaskCallOptions, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type ThrowsList, type Timer, TimerStatus, TimerType, type TunnelEventSelector, type TunnelMode, type TunnelRunner, type TunnelTagConfig, type TunnelTaskRunner, type TunnelTaskSelector, type TypeDefinition, type UnhandledErrorKind, type UnionToIntersection, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext, createDashboardMiddleware, createDefaultUnhandledError, createDurableAuditEntryId, createDurableRunnerAuditEmitter, createDurableStepId, createDurableTestSetup, createExposureFetch, createHttpClient, createHttpMixedClient, createHttpSmartClient, createNodeFile, createTestResource, debug, debugLevels, defs as definitions, disposeDurableService, durableEvents, durableEventsArray, durableResource, defineEvent as event, getConfig, getDefaultSerializer, globals, hasExposureContext, defineHook as hook, initDurableService, initDurableWorker, isDurableInternalStepId, isOneOf, journal, levelNormal, levelVerbose, nodeExposure, normalizeError, onAnyOf, defineOverride as override, r, readInputFileToBuffer, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, symbolAsyncContext, symbolError, symbolEvent, symbolFilePath, symbolHook, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolPhantomTask, symbolResource, symbolResourceForkedFrom, symbolResourceMiddleware, symbolResourceWithConfig, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, symbolTunneledBy, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware, useExposureContext, waitUntil, writeInputFileToPath };