@bluelibs/runner 5.1.0 → 5.2.1

package/dist/node/node.d.mts

@@ -1,4622 +0,0 @@
-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';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { Request, Router } from 'express';
-
-/**
- * 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, 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> {
-    readonly __containsContract: true;
-    readonly [CONTRACT]: {
-        config: TConfig;
-        input: TInput;
-        output: TOutput;
-    };
-}
-type NonVoid<T> = [T] extends [void] ? never : T;
-type IsTuple<T extends readonly unknown[]> = number extends T["length"] ? false : true;
-type UnionToIntersection$1<U> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
-type UnknownToNever<T> = IsUnknown<T> extends true ? never : T;
-type ExtractContractOf<T, Kind extends "input" | "output"> = T extends IContractable<any, infer I, infer O> ? UnknownToNever<Kind extends "input" ? NonVoid<I> : NonVoid<O>> : never;
-type FilterContractsKind<TItems extends readonly unknown[], Kind extends "input" | "output", Acc extends readonly unknown[] = []> = TItems extends readonly [infer H, ...infer R] ? ExtractContractOf<H, Kind> extends never ? FilterContractsKind<R, Kind, Acc> : FilterContractsKind<R, Kind, [...Acc, ExtractContractOf<H, Kind>]> : Acc;
-type ExtractContractsFromCollection<TItems extends readonly unknown[], Kind extends "input" | "output"> = IsTuple<TItems> extends true ? FilterContractsKind<TItems, Kind> : Array<ExtractContractOf<TItems[number], Kind>>;
-type ExtractInputTypeFromContracts<TItems extends readonly unknown[]> = ExtractContractsFromCollection<TItems, "input">;
-type ExtractOutputTypeFromContracts<TItems extends readonly unknown[]> = ExtractContractsFromCollection<TItems, "output">;
-type ContractsUnionInputs<TItems extends readonly unknown[]> = ExtractInputTypeFromContracts<TItems> extends readonly (infer U)[] ? U : never;
-type ContractsUnionOutputs<TItems extends readonly unknown[]> = ExtractOutputTypeFromContracts<TItems> extends readonly (infer U)[] ? U : never;
-type ContractsIntersectionInputs<TItems extends readonly unknown[]> = UnionToIntersection$1<ContractsUnionInputs<TItems>>;
-type ContractsIntersectionOutputs<TItems extends readonly unknown[]> = UnionToIntersection$1<ContractsUnionOutputs<TItems>>;
-type HasInputContracts<TItems extends readonly unknown[]> = [
-    ContractsUnionInputs<TItems>
-] extends [never] ? false : true;
-type HasOutputContracts<TItems extends readonly unknown[]> = [
-    ContractsUnionOutputs<TItems>
-] extends [never] ? false : true;
-type IsNever<T> = [T] extends [never] ? true : false;
-type KeysWithNever<T> = T extends object ? {
-    [K in keyof T]-?: [T[K]] extends [never] ? K : never;
-}[keyof T] : never;
-type HasNeverProperty<T> = KeysWithNever<T> extends never ? false : true;
-type IsImpossibleIntersection<T> = IsNever<T> extends true ? true : HasNeverProperty<T> extends true ? true : false;
-type InputContractViolationError<TItems extends readonly unknown[], TActual> = {
-    message: "Value does not satisfy all input contracts";
-    expected: Simplify<ContractsIntersectionInputs<TItems>>;
-    received: TActual;
-};
-type OutputContractViolationError<TItems extends readonly unknown[], TActual> = {
-    message: "Value does not satisfy all output contracts";
-    expected: Simplify<ContractsIntersectionOutputs<TItems>>;
-    received: TActual;
-};
-type EnsureInputSatisfiesContracts<TItems extends readonly unknown[], TValue> = [ContractsUnionInputs<TItems>] extends [never] ? TValue : TValue extends Promise<infer U> ? Promise<U extends ContractsIntersectionInputs<TItems> ? U : InputContractViolationError<TItems, U>> : TValue extends ContractsIntersectionInputs<TItems> ? TValue : InputContractViolationError<TItems, TValue>;
-type EnsureOutputSatisfiesContracts<TItems extends readonly unknown[], TResponse> = [ContractsUnionOutputs<TItems>] extends [never] ? TResponse : TResponse extends Promise<infer U> ? Promise<U extends ContractsIntersectionOutputs<TItems> ? U : OutputContractViolationError<TItems, U>> : TResponse extends ContractsIntersectionOutputs<TItems> ? TResponse : OutputContractViolationError<TItems, TResponse>;
-type InferInputOrViolationFromContracts<TItems extends readonly unknown[]> = HasInputContracts<TItems> extends false ? void : ContractsIntersectionInputs<TItems> extends infer I ? IsImpossibleIntersection<I> extends true ? InputContractViolationError<TItems, Simplify<I extends never ? never : I>> : Simplify<I> : never;
-
-/**
- * Common metadata you can attach to tasks/resources/events/middleware.
- * Useful for docs, filtering and middleware decisions.
- */
-interface IMeta {
-    title?: string;
-    description?: string;
-}
-interface ITaskMeta extends IMeta {
-}
-interface IResourceMeta extends IMeta {
-}
-interface IEventMeta extends IMeta {
-}
-interface IMiddlewareMeta extends IMeta {
-}
-interface ITagMeta extends IMeta {
-}
-interface IErrorMeta extends IMeta {
-}
-interface IAsyncContextMeta extends IMeta {
-}
-
-interface ITaggable {
-    tags: TagType[];
-}
-interface ITagDefinition<TConfig = void, _TEnforceInputContract = void, _TEnforceOutputContract = void> {
-    id: string;
-    meta?: ITagMeta;
-    configSchema?: IValidationSchema<TConfig>;
-    /**
-     * Utilizing config at definition level stores its defaults
-     */
-    config?: TConfig;
-}
-interface ITag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void> extends ITagDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
-    /**
-     * A special validation property.
-     * It resolves to `true` if TConfig only has optional keys, otherwise `false`.
-     */
-    readonly __configHasOnlyOptionalKeys: RequiredKeys<TConfig> extends never ? true : false;
-    config?: TConfig;
-    /**
-     * Checks if the tag exists in a taggable or a list of tags.
-     */
-    exists(target: ITaggable | TagType[]): boolean;
-    /**
-     * Creates a configured instance of the tag.
-     */
-    with(config: TConfig): ITagConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract>;
-    /**
-     * Extracts the configuration of the tag from a taggable or a list of tags.
-     */
-    extract(target: ITaggable | TagType[]): TConfig | undefined;
-    [symbolFilePath]: string;
-    [symbolTag]: true;
-}
-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> {
-    [symbolTagConfigured]: true;
-    config: TConfig;
-}
-type TagType = ITag<void, any, any> | ITagWithOptionalConfig<any, any, any> | ITagConfigured<any, any, any>;
-
-/**
- * Internal brand symbols used to tag created objects at runtime and help with
- * type‑narrowing. Prefer the `isTask`/`isResource`/`isEvent`/`isMiddleware`
- * helpers instead of touching these directly.
- * @internal
- */
-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 */
-declare const symbolError: unique symbol;
-declare const symbolMiddleware: unique symbol;
-/** New brands for separated middleware kinds */
-declare const symbolTaskMiddleware: unique symbol;
-declare const symbolResourceMiddleware: unique symbol;
-declare const symbolMiddlewareConfigured: unique symbol;
-/** Records which tunnel resource owns the task patching (exclusivity). */
-declare const symbolTunneledBy: unique symbol;
-/** @internal Marks hook definitions (event listeners without middleware) */
-declare const symbolHook: unique symbol;
-/** @internal Marks a tag definition */
-declare const symbolTag: unique symbol;
-declare const symbolTagConfigured: unique symbol;
-/** @internal Marks an optional dependency wrapper */
-declare const symbolOptionalDependency: unique symbol;
-/** @internal Path to aid anonymous id generation and error messages */
-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[]> {
-    /** Stable identifier. */
-    id: string;
-    /** Static or lazy dependency map. Receives `config` when provided. */
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-    /**
-     * Register other registerables (resources/tasks/middleware/events). Accepts a
-     * static array or a function of `config` to support dynamic wiring.
-     */
-    register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    /**
-     * Initialize and return the resource value. Called once during boot.
-     */
-    init?: (config: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? IsUnspecified<TConfig> extends true ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : EnsureInputSatisfiesContracts<[...TTags, ...TMiddleware], TConfig> : TConfig, dependencies: ResourceDependencyValuesType<TDependencies>, context: TContext) => HasOutputContracts<[...TTags, ...TMiddleware]> extends true ? EnsureOutputSatisfiesContracts<[...TTags, ...TMiddleware], TValue> : TValue;
-    /**
-     * Optional validation schema for the resource's resolved value.
-     * When provided, the value will be validated immediately after `init` resolves,
-     * without considering middleware.
-     */
-    resultSchema?: IValidationSchema<TValue extends Promise<infer U> ? U : TValue>;
-    /**
-     * Clean-up function for the resource. This is called when the resource is no longer needed.
-     *
-     * @param value The value of the resource (undefined if no init method)
-     * @param config The configuration it received
-     * @param dependencies The dependencies it needed
-     * @returns Promise<void>
-     */
-    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.
-     */
-    configSchema?: IValidationSchema<TConfig>;
-    /**
-     * Safe overrides to swap behavior while preserving identities. See
-     * README: Overrides.
-     */
-    overrides?: Array<OverridableElements>;
-    /** Middleware applied around init/dispose. */
-    middleware?: TMiddleware;
-    /**
-     * Create a private, mutable context shared between `init` and `dispose`.
-     */
-    context?: () => TContext;
-    /**
-     * This is optional and used from an index resource to get the correct caller.
-     * This is the reason we allow it here as well.
-     */
-    [symbolFilePath]?: string;
-    tags?: TTags;
-}
-/**
- * Helper alias describing the canonical resource init call signature.
- * Shared with fluent builders to keep init typing consistent.
- */
-type ResourceInitFn<TConfig, TValue extends Promise<any>, TDependencies extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]> = NonNullable<IResourceDefinition<TConfig, TValue, TDependencies, TContext, any, any, TMeta, TTags, TMiddleware>["init"]>;
-interface 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[]> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext, any, any, TMeta, TTags, TMiddleware> {
-    id: string;
-    with(config: HasInputContracts<[...TTags, ...TMiddleware]> extends true ? IsUnspecified<TConfig> extends true ? InferInputOrViolationFromContracts<[...TTags, ...TMiddleware]> : TConfig : TConfig): IResourceWithConfig<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
-    register: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    overrides: Array<OverridableElements>;
-    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;
-    /** The id of the underlying resource. */
-    id: string;
-    /** The underlying resource definition. */
-    resource: IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>;
-    /** The configuration captured by `.with(config)`. */
-    config: TConfig;
-}
-
-/**
- * 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 {
-    /**
-     * If true, allows overwriting an existing value.
-     * By default, attempting to set a key that already exists will throw an error.
-     */
-    override?: boolean;
-}
-/**
- * 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;
-}
-
-interface ITaskMiddlewareDefinition<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 task execution input.
-     */
-    run: (input: ITaskMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-    tags?: TagType[];
-    everywhere?: boolean | ((task: ITask<any, any, any, any>) => boolean);
-}
-interface ITaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
-    [symbolTaskMiddleware]: true;
-    [symbolFilePath]: string;
-    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) => ITaskMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-    tags: TagType[];
-}
-interface ITaskMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-    config: TConfig;
-}
-interface ITaskMiddlewareExecutionInput<TTaskInput = any, TTaskOutput = any> {
-    /** Task hook */
-    task: {
-        definition: ITask<TTaskInput, any, any, 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 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>;
-    /**
-     * 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 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;
-    /** 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;
-/**
- * Runtime guard that checks if an emission belongs to one of the given event defs.
- * Narrows payload type to the intersection of the provided events' payloads.
- */
-declare function isOneOf<TDefs extends readonly IEventDefinition<any>[]>(emission: IEventEmission<any>, defs: TDefs): emission is IEventEmission<CommonPayload<TDefs>>;
-interface IEventDefinition<TPayload = void> {
-    id: string;
-    meta?: IEventMeta;
-    /**
-     * Optional validation schema for runtime payload validation.
-     * When provided, event payload will be validated when emitted.
-     */
-    payloadSchema?: IValidationSchema<TPayload>;
-    tags?: TagType[];
-    /**
-     * If true, listeners with the same priority run concurrently within a batch.
-     * Batches (grouped by order) still execute sequentially in priority order.
-     */
-    parallel?: boolean;
-}
-/**
- * The definioten of the event.
- * This is different from the event emission.
- */
-interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
-    id: string;
-    /**
-     * We use this event to discriminate between resources with just 'id' and 'events' as they collide. This is a workaround, should be redone using classes and instanceof.
-     */
-    [symbolEvent]: true;
-    [symbolFilePath]: string;
-    /** Return an optional dependency wrapper for this event. */
-    optional: () => IOptionalDependency<IEvent<TPayload>>;
-    tags: TagType[];
-}
-/**
- * This represents the object that is passed to event handlers
- */
-interface IEventEmission<TPayload = any> {
-    /**
-     * The ID of the event. This is the same as the event's ID.
-     * This is useful for global event listeners.
-     */
-    id: string;
-    /**
-     * The data that the event carries. It can be anything.
-     */
-    data: TPayload;
-    /**
-     * The timestamp when the event was created.
-     */
-    timestamp: Date;
-    /**
-     * The source of the event. This can be useful for debugging.
-     */
-    source: string;
-    /**
-     * Metadata associated with the event definition.
-     */
-    meta: IEventMeta;
-    /**
-     * Stops propagation to remaining event listeners.
-     */
-    stopPropagation(): void;
-    /**
-     * Returns true if propagation has been stopped.
-     */
-    isPropagationStopped(): boolean;
-    /**
-     * The tags that the event carries.
-     */
-    tags: TagType[];
-}
-
-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[];
-}
-
-interface IAsyncContextDefinition<T> {
-    id: string;
-    serialize?(data: T): string;
-    parse?(data: string): T;
-    /**
-     * When provided, context values will be validated when provide() is called.
-     */
-    configSchema?: IValidationSchema<T>;
-    meta?: IAsyncContextMeta;
-}
-/**
- * The generic AsyncContext object returned by `defineAsyncContext`.
- */
-interface IAsyncContext<T> {
-    /** unique symbol used as key in the AsyncLocalStorage map */
-    readonly id: string;
-    /** Brand marker for registration and runtime checks */
-    [symbolAsyncContext]: true;
-    /** Retrieve the current context value or throw */
-    use(): T;
-    /**
-     * Provide a value for this context during the lifetime of `fn()`
-     */
-    provide<R>(value: T, fn: () => Promise<R> | R): Promise<R> | R;
-    /**
-     * Generates a middleware that guarantees the context exists (and optionally
-     * enforces that certain keys are present on the context object).
-     */
-    require<K extends keyof T = never>(keys?: K[]): ITaskMiddlewareConfigured<{
-        context: IAsyncContext<T>;
-    }>;
-    serialize(data: T): string;
-    parse(data: string): T;
-    /** Return an optional dependency wrapper for this context */
-    optional(): IOptionalDependency<IAsyncContext<T>>;
-}
-
-/**
- * Generic validation schema interface that can be implemented by any validation library.
- * Compatible with Zod, Yup, Joi, and other validation libraries.
- */
-interface IValidationSchema<T = any> {
-    /**
-     * Parse and validate the input data.
-     * Should throw an error if validation fails.
-     * Can transform the data if the schema supports transformations.
-     */
-    parse(input: unknown): T;
-}
-/**
- * Core public TypeScript types for BlueLibs Runner.
- *
- * This file contains the strongly-typed contract for tasks, resources, events
- * and middleware. It mirrors the mental model described in the README:
- * - Tasks are functions
- * - Resources are singletons (with init/dispose hooks)
- * - Events are simple, strongly-typed emissions
- * - Middleware can target both tasks and resources
- *
- * DX goals:
- * - Crystal‑clear generics and helper types that infer dependency shapes
- * - Friendly JSDoc you can hover in editors to understand usage instantly
- * - Safe overrides and strong typing around config and register mechanics
- */
-type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
-}[keyof T];
-/**
- * The reason we accept null and undefined is because we want to be able to offer beautiful DX:
- * overrides: [
- *    process.env.NODE_ENV === 'production' ? prodEmailer : null,
- * ]
- */
-type OverridableElements = IResource<any, any, any, any, any> | ITask<any, any, any, any> | ITaskMiddleware<any> | IResourceMiddleware<any, any> | IResourceWithConfig<any, any, any> | IHook<any, any> | undefined | null;
-/**
- * A mapping of dependency keys to Runner definitions. Used in `dependencies`
- * for tasks and resources. Values are later transformed into the actual
- * callable/value shape by `DependencyValuesType`.
- */
-type DependencyMapType = Record<string, ITask<any, any, any, any, any, any> | IResource<any, any, any, any, any, any, any> | IEvent<any> | IErrorHelper<any> | IAsyncContext<any> | IOptionalDependency<ITask<any, any, any, any, any, any>> | IOptionalDependency<IResource<any, any, any, any, any, any, any>> | IOptionalDependency<IEvent<any>> | IOptionalDependency<IErrorHelper<any>> | IOptionalDependency<IAsyncContext<any>>>;
-/** Wrapper type marking a dependency as optional at wiring time */
-interface IOptionalDependency<T> {
-    /** The wrapped dependency definition */
-    inner: 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 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 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. Optionally accepts TaskCallOptions for journal forwarding.
- */
-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.
- */
-type ResourceDependency<V> = V;
-/**
- * Event dependencies resolve to an emitter function. If the payload type is
- * `void`, the function can be called with zero args (or an empty object).
- */
-type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Record<string, never>) => Promise<void>) : (input: P) => Promise<void>;
-/**
- * Transforms a dependency definition into the usable shape inside `run`/`init`:
- * - Task -> callable function
- * - Resource -> resolved value
- * - Event -> emit function
- */
-type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IErrorHelper<any> ? T : T extends IAsyncContext<any> ? T : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? DependencyValueType<U> | undefined : never;
-type DependencyValuesType<T extends DependencyMapType> = {
-    [K in keyof T]: DependencyValueType<T[K]>;
-};
-type TaskLocalInterceptor<TInput, TOutput> = (next: (input: TInput) => TOutput, input: TInput) => TOutput;
-type TaskDependencyWithIntercept<TInput, TOutput> = TaskDependency<TInput, TOutput> & {
-    intercept: (middleware: TaskLocalInterceptor<TInput, TOutput>) => void;
-};
-/** Resource-context dependency typing where tasks expose intercept() */
-type ResourceDependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependencyWithIntercept<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IErrorHelper<any> ? T : T extends IAsyncContext<any> ? T : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? ResourceDependencyValueType<U> | undefined : never;
-type ResourceDependencyValuesType<T extends DependencyMapType> = {
-    [K in keyof T]: ResourceDependencyValueType<T[K]>;
-};
-/**
- * Anything you can put inside a resource's `register: []`.
- * - Resources (with or without `.with()`)
- * - Tasks
- * - Middleware
- * - Events
- */
-type RegisterableItems = IResourceWithConfig<any, any, any, any, any, any, any> | IResource<void, any, any, any, any, any, any> | IResource<{
-    [K in any]?: any;
-}, any, any, any, any, any, any> | ITask<any, any, any, any, any, any> | IHook<any, any> | ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any> | IEvent<any> | IAsyncContext<any> | IErrorHelper<any> | ITag<any, any, any>;
-
-interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
-    id: string;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
-        override?: false;
-    }): TaskMiddlewareFluentBuilder<C, In, Out, D & TNewDeps>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options: {
-        override: true;
-    }): TaskMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
-    configSchema<TNew>(schema: IValidationSchema<TNew>): TaskMiddlewareFluentBuilder<TNew, In, Out, D>;
-    run(fn: ITaskMiddlewareDefinition<C, In, Out, D>["run"]): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-    meta<TNewMeta extends IMiddlewareMeta>(m: TNewMeta): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: boolean;
-    }): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-    everywhere(flag: boolean | ((task: ITask<any, any, any, any>) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-    build(): ITaskMiddleware<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?: {
-        override?: false;
-    }): ResourceMiddlewareFluentBuilder<C, In, Out, D & TNewDeps>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options: {
-        override: true;
-    }): ResourceMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
-    configSchema<TNew>(schema: IValidationSchema<TNew>): ResourceMiddlewareFluentBuilder<TNew, In, Out, D>;
-    run(fn: IResourceMiddlewareDefinition<C, In, Out, D>["run"]): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
-    meta<TNewMeta extends IMiddlewareMeta>(m: TNewMeta): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: boolean;
-    }): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
-    everywhere(flag: boolean | ((resource: IResource<any, any, any, any, any>) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
-    build(): IResourceMiddleware<C, In, Out, D>;
-}
-
-/**
- * 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(): 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> {
-    id: string;
-    serialize(fn: (data: T) => string): AsyncContextFluentBuilder<T>;
-    parse(fn: (raw: string) => T): AsyncContextFluentBuilder<T>;
-    configSchema(schema: IValidationSchema<T>): AsyncContextFluentBuilder<T>;
-    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> {
-    id: string;
-    meta<TNewMeta extends ITagMeta>(m: TNewMeta): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
-    configSchema<TNewConfig>(schema: IValidationSchema<TNewConfig>): TagFluentBuilder<TNewConfig, TEnforceIn, TEnforceOut>;
-    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>;
-
-/** 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 ValidOnTarget>(on: TNewOn): HookFluentBuilder<TDeps, TNewOn, TMeta>;
-    order(order: number): HookFluentBuilder<TDeps, TOn, TMeta>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options?: {
-        override?: false;
-    }): HookFluentBuilder<TDeps & TNewDeps, TOn, TMeta>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
-        override: true;
-    }): HookFluentBuilder<TNewDeps, TOn, TMeta>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: boolean;
-    }): HookFluentBuilder<TDeps, TOn, TMeta>;
-    meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookFluentBuilder<TDeps, TOn, TNewMeta>;
-    /** 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>;
-}
-
-/**
- * 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;
-    payloadSchema<TNew>(schema: IValidationSchema<TNew>): EventFluentBuilder<TNew>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: boolean;
-    }): EventFluentBuilder<TPayload>;
-    meta<TNewMeta extends IEventMeta>(m: TNewMeta): EventFluentBuilder<TPayload>;
-    /**
-     * Enable parallel execution for this event's listeners.
-     * When enabled, listeners with the same `order` run concurrently within a batch.
-     * Batches execute sequentially in ascending order priority.
-     *
-     * @param enabled - Whether to enable parallel execution (default: true)
-     */
-    parallel(enabled?: boolean): EventFluentBuilder<TPayload>;
-    build(): IEvent<TPayload>;
-}
-
-/**
- * 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;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
-        override: true;
-    }): TaskFluentBuilder<TInput, TOutput, TNewDeps, TMeta, TTags, TMiddleware>;
-    middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
-        override?: boolean;
-    }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TNewMw>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: false;
-    }): TaskFluentBuilder<TInput, TOutput, 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>;
-    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>;
-}
-
-/**
- * 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;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps & TNewDeps, TMeta, TTags, TMiddleware>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | (() => TNewDeps), options: {
-        override: true;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TNewDeps, TMeta, TTags, TMiddleware>;
-    middleware<TNewMw extends TaskMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
-        override?: boolean;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, TDeps, TMeta, TTags, TNewMw>;
-    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
-        override?: false;
-    }): PhantomTaskFluentBuilder<TInput, TResolved, 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>;
-    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: 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?: {
-        override?: false;
-    }): ResourceFluentBuilder<TConfig, TValue, TDeps & TNewDeps, TContext, TMeta, TTags, TMiddleware>;
-    dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: TConfig) => TNewDeps), options: {
-        override: true;
-    }): ResourceFluentBuilder<TConfig, TValue, TNewDeps, TContext, TMeta, TTags, TMiddleware>;
-    register(items: RegisterableItems | Array<RegisterableItems> | ((config: TConfig) => RegisterableItems | Array<RegisterableItems>), options?: {
-        override?: boolean;
-    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
-    middleware<TNewMw extends ResourceMiddlewareAttachmentType[]>(mw: TNewMw, options?: {
-        override?: boolean;
-    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TNewMw>;
-    tags<TNewTags extends TagType[]>(tags: TNewTags, options?: {
-        override?: false;
-    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, [
-        ...TTags,
-        ...TNewTags
-    ], TMiddleware>;
-    tags<TNewTags extends TagType[]>(tags: TNewTags, options: {
-        override: true;
-    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TNewTags, TMiddleware>;
-    context<TNewCtx>(factory: () => TNewCtx): ResourceFluentBuilder<TConfig, TValue, TDeps, TNewCtx, TMeta, TTags, TMiddleware>;
-    configSchema<TNewConfig>(schema: IValidationSchema<TNewConfig>): ResourceFluentBuilder<TNewConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
-    resultSchema<TResolved>(schema: IValidationSchema<TResolved>): ResourceFluentBuilder<TConfig, Promise<TResolved>, TDeps, TContext, TMeta, TTags, TMiddleware>;
-    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 {
-    /**
-     * Preferred configuration shape: explicit per-side allowlist.
-     */
-    client?: TunnelTaskMiddlewarePolicySideConfig;
-    server?: TunnelTaskMiddlewarePolicySideConfig;
-    /**
-     * Backwards-compatible configuration shape (previous): grouped allowlists.
-     */
-    middlewareAllowList?: {
-        client?: TunnelMiddlewareId[];
-        server?: TunnelMiddlewareId[];
-    };
-}
-
-interface TimeoutMiddlewareConfig {
-    /**
-     * Maximum time in milliseconds before the wrapped operation is aborted
-     * and a timeout error is thrown. Defaults to 5000ms.
-     */
-    ttl: number;
-}
-
-/**
- * Configuration options for the retry middleware
- */
-interface RetryMiddlewareConfig {
-    /**
-     * Maximum number of retry attempts (default: 3)
-     */
-    retries?: number;
-    /**
-     * Callback to determine if retry should stop based on error
-     * @default () => false (retry all errors)
-     */
-    stopRetryIf?: (error: Error) => boolean;
-    /**
-     * Custom delay strategy function
-     * @default Exponential backoff starting at 100ms
-     */
-    delayStrategy?: (attempt: number, error: Error) => number;
-}
-
-interface FallbackMiddlewareConfig {
-    /**
-     * The fallback to use if the task fails.
-     * Can be a value, a function that returns a value (or promise), or another task.
-     */
-    fallback: any;
-}
-
-declare const SemaphoreEvents: {
-    readonly queued: IEvent<SemaphoreEvent>;
-    readonly acquired: IEvent<SemaphoreEvent>;
-    readonly released: IEvent<SemaphoreEvent>;
-    readonly timeout: IEvent<SemaphoreEvent>;
-    readonly aborted: IEvent<SemaphoreEvent>;
-    readonly disposed: IEvent<SemaphoreEvent>;
-};
-type SemaphoreEventType = keyof typeof SemaphoreEvents;
-type SemaphoreEvent = {
-    type: SemaphoreEventType;
-    permits: number;
-    waiting: number;
-    maxPermits: number;
-    disposed: boolean;
-};
-/**
- * A semaphore that limits the number of concurrent operations.
- * Used to prevent connection pool exhaustion by limiting concurrent
- * database operations to the pool size.
- */
-declare class Semaphore {
-    private permits;
-    private waitingHead;
-    private waitingTail;
-    private waitingCount;
-    private disposed;
-    private readonly maxPermits;
-    private readonly eventManager;
-    private listenerId;
-    private activeListeners;
-    constructor(maxPermits: number);
-    /**
-     * Acquire a permit. If no permits are available, waits until one becomes available.
-     */
-    acquire(options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Release a permit, allowing waiting operations to proceed.
-     */
-    release(): void;
-    private removeFromQueue;
-    /**
-     * Execute a function with a permit, automatically releasing it afterwards.
-     */
-    withPermit<T>(fn: () => Promise<T>, options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<T>;
-    /**
-     * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
-     */
-    dispose(): void;
-    /**
-     * Get current number of available permits (for debugging)
-     */
-    getAvailablePermits(): number;
-    /**
-     * Get current number of waiting operations (for debugging)
-     */
-    getWaitingCount(): number;
-    /**
-     * Get maximum number of permits
-     */
-    getMaxPermits(): number;
-    /**
-     * Check if the semaphore has been disposed
-     */
-    isDisposed(): boolean;
-    /**
-     * Get metrics about the current state of the semaphore
-     */
-    getMetrics(): {
-        availablePermits: number;
-        waitingCount: number;
-        maxPermits: number;
-        utilization: number;
-        disposed: boolean;
-    };
-    on(type: SemaphoreEventType, handler: (event: SemaphoreEvent) => any): () => void;
-    once(type: SemaphoreEventType, handler: (event: SemaphoreEvent) => any): () => void;
-    private enqueue;
-    private dequeue;
-    private emit;
-    private buildEvent;
-}
-
-interface ConcurrencyMiddlewareConfig {
-    /**
-     * Maximum number of concurrent executions.
-     * If provided, a Semaphore will be created and shared for this config object.
-     */
-    limit?: number;
-    /**
-     * Optional key to identify a shared semaphore.
-     * If provided, the semaphore will be shared across all tasks using the same key.
-     */
-    key?: string;
-    /**
-     * An existing Semaphore instance to use.
-     */
-    semaphore?: Semaphore;
-}
-
-interface TemporalMiddlewareConfig {
-    ms: number;
-}
-interface DebounceState {
-    timeoutId?: NodeJS.Timeout;
-    latestInput?: any;
-    resolveList: ((value: any) => void)[];
-    rejectList: ((error: any) => void)[];
-}
-interface ThrottleState {
-    lastExecution: number;
-    timeoutId?: NodeJS.Timeout;
-    latestInput?: any;
-    resolveList: ((value: any) => void)[];
-    rejectList: ((error: any) => void)[];
-    currentPromise?: Promise<any>;
-}
-
-/**
- * States of the Circuit Breaker
- */
-declare enum CircuitBreakerState {
-    CLOSED = "CLOSED",
-    OPEN = "OPEN",
-    HALF_OPEN = "HALF_OPEN"
-}
-/**
- * Configuration for the Circuit Breaker middleware
- */
-interface CircuitBreakerMiddlewareConfig {
-    /**
-     * Number of failures before tripping the circuit
-     * @default 5
-     */
-    failureThreshold?: number;
-    /**
-     * Time in milliseconds before transitioning from OPEN to HALF_OPEN
-     * @default 30000 (30 seconds)
-     */
-    resetTimeout?: number;
-}
-interface CircuitBreakerStatus {
-    state: CircuitBreakerState;
-    failures: number;
-    lastFailureTime: number;
-}
-
-interface RateLimitMiddlewareConfig {
-    /**
-     * Time window in milliseconds
-     */
-    windowMs: number;
-    /**
-     * Maximum number of requests within the window
-     */
-    max: number;
-}
-interface RateLimitState {
-    count: number;
-    resetTime: number;
-}
-
-/**
- * Options for configuring event listeners.
- */
-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
-     * @param handler - The callback function to handle the event
-     * @param options - Configuration options for the listener
-     */
-    addListener<T>(event: IEvent<T> | Array<IEvent<T>>, handler: EventHandlerType<T>, options?: IEventHandlerOptions<T>): void;
-    /**
-     * Registers a global event listener that handles all events.
-     * Global listeners are mixed with specific listeners and ordered by priority.
-     *
-     * @param handler - The callback function to handle events
-     * @param options - Configuration options for the listener
-     */
-    addGlobalListener(handler: EventHandlerType, options?: IEventHandlerOptions): void;
-    /**
-     * Checks if there are any listeners registered for the given event
-     *
-     * @param eventDefinition - The event definition to check
-     * @returns true if listeners exist, false otherwise
-     */
-    hasListeners<T>(eventDefinition: IEvent<T>): boolean;
-    /**
-     * Adds an interceptor for all event emissions
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent event emissions
-     *
-     * @param interceptor - The interceptor function to add
-     */
-    intercept(interceptor: EventEmissionInterceptor): void;
-    /**
-     * Adds an interceptor for hook execution
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent hook execution
-     *
-     * @param interceptor - The interceptor function to add
-     */
-    interceptHook(interceptor: HookExecutionInterceptor): void;
-    /**
-     * Executes a hook with all registered hook interceptors applied
-     * This method should be used by TaskRunner when executing hooks
-     *
-     * @param hook - The hook to execute
-     * @param event - The event that triggered the hook
-     * @param computedDependencies - The computed dependencies for the hook
-     * @returns Promise resolving to the hook execution result
-     */
-    executeHookWithInterceptors(hook: IHook<any, any>, event: IEventEmission<any>, computedDependencies: DependencyValuesType<any>): Promise<any>;
-    /**
-     * Throws an error if the EventManager is locked
-     */
-    private checkLock;
-    /**
-     * 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).
-     */
-    private getCachedMergedListeners;
-}
-
-type PrintStrategy$1 = "pretty" | "plain" | "json" | "json_pretty";
-type LogLevels$1 = "trace" | "debug" | "info" | "warn" | "error" | "critical";
-interface PrintableLog {
-    level: LogLevels$1;
-    source?: string;
-    message: any;
-    timestamp: Date;
-    error?: {
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-}
-type ColorTheme = {
-    trace: string;
-    debug: string;
-    info: string;
-    warn: string;
-    error: string;
-    critical: string;
-    reset: string;
-    bold: string;
-    dim: string;
-    blue: string;
-    cyan: string;
-    gray: string;
-};
-declare class LogPrinter {
-    private strategy;
-    private colors;
-    constructor(options: {
-        strategy: PrintStrategy$1;
-        useColors: boolean;
-        colorTheme?: Partial<ColorTheme>;
-    });
-    print(log: PrintableLog): void;
-    private pickWriter;
-    private formatTime;
-    private formatLevel;
-    private formatSource;
-    private formatMessage;
-    private formatError;
-    private formatData;
-    private formatContext;
-    private normalizeForJson;
-    private static NO_COLORS;
-    private static readonly DEFAULT_WRITERS;
-    private static writers;
-    static setWriters(writers: Partial<{
-        log: (msg: any) => void;
-        error?: (msg: any) => void;
-    }>): void;
-    static resetWriters(): void;
-}
-
-type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critical";
-interface ILogInfo {
-    source?: string;
-    error?: unknown | Error;
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-    [key: string]: any;
-}
-interface ILog {
-    level: LogLevels;
-    source?: string;
-    message: any;
-    timestamp: Date;
-    error?: {
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-}
-type PrintStrategy = PrintStrategy$1;
-declare class Logger {
-    private printThreshold;
-    private printStrategy;
-    private bufferLogs;
-    private buffer;
-    private boundContext;
-    private isLocked;
-    private useColors;
-    private printer;
-    private source?;
-    private rootLogger?;
-    localListeners: Array<(log: ILog) => void | Promise<void>>;
-    static Severity: {
-        trace: number;
-        debug: number;
-        info: number;
-        warn: number;
-        error: number;
-        critical: number;
-    };
-    constructor(options: {
-        printThreshold: null | LogLevels;
-        printStrategy: PrintStrategy;
-        bufferLogs: boolean;
-        useColors?: boolean;
-    }, boundContext?: Record<string, any>, source?: string, printer?: LogPrinter);
-    private detectColorSupport;
-    /**
-     * Creates a new logger instance with additional bound context
-     */
-    with({ source, additionalContext: context, }: {
-        source?: string;
-        additionalContext?: Record<string, any>;
-    }): Logger;
-    /**
-     * Core logging method with structured LogInfo
-     */
-    log(level: LogLevels, message: any, logInfo?: ILogInfo): Promise<void>;
-    private extractErrorInfo;
-    info(message: any, logInfo?: ILogInfo): Promise<void>;
-    error(message: any, logInfo?: ILogInfo): Promise<void>;
-    warn(message: any, logInfo?: ILogInfo): Promise<void>;
-    debug(message: any, logInfo?: ILogInfo): Promise<void>;
-    trace(message: any, logInfo?: ILogInfo): Promise<void>;
-    critical(message: any, logInfo?: ILogInfo): Promise<void>;
-    /**
-     * Direct print for tests and advanced scenarios. Delegates to LogPrinter.
-     */
-    print(log: ILog): void;
-    /**
-     * @param listener - A listener that will be triggered for every log.
-     */
-    onLog(listener: (log: ILog) => any): void;
-    /**
-     * Marks the logger as ready.
-     * This is used to trigger the local listeners and print the buffered logs (if they exists)
-     * @returns A promise that resolves when the logger is ready.
-     */
-    lock(): Promise<void>;
-    private canPrint;
-    private triggerLogListeners;
-}
-
-type ResourceStoreElementType<C = any, V extends Promise<any> = any, D extends DependencyMapType = {}, TContext = any> = {
-    resource: IResource<C, V, D>;
-    computedDependencies?: ResourceDependencyValuesType<D>;
-    config: C;
-    value: V;
-    context: TContext;
-    isInitialized?: boolean;
-};
-type TaskStoreElementType<Input = any, Output extends Promise<any> = any, D extends DependencyMapType = any> = {
-    task: ITask<Input, Output, D>;
-    computedDependencies: DependencyValuesType<D>;
-    isInitialized: boolean;
-    interceptors?: Array<TaskLocalInterceptor<any, any>>;
-};
-type HookStoreElementType<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition = any> = {
-    hook: IHook<D, TOn>;
-    computedDependencies: DependencyValuesType<D>;
-};
-type TaskMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = {
-    middleware: ITaskMiddleware<any, TDeps>;
-    computedDependencies: DependencyValuesType<TDeps>;
-    isInitialized: boolean;
-};
-type ResourceMiddlewareStoreElementType<TDeps extends DependencyMapType = any> = {
-    middleware: IResourceMiddleware<any, TDeps>;
-    computedDependencies: DependencyValuesType<TDeps>;
-    isInitialized: boolean;
-};
-type EventStoreElementType = {
-    event: IEvent<any>;
-};
-
-declare class TaskRunner {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    protected readonly runnerStore: Map<string | symbol, (input: any, journal?: ExecutionJournal) => Promise<any>>;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    private readonly middlewareManager;
-    /**
-     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
-     * 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, options?: TaskCallOptions): Promise<TOutput | undefined>;
-    /**
-     * Creates the function with the chain of middleware.
-     * @param task
-     * @param input
-     * @param taskDependencies
-     * @returns
-     */
-    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";
-interface OnUnhandledErrorInfo {
-    error: unknown;
-    kind?: UnhandledErrorKind;
-    source?: string;
-}
-type OnUnhandledError = (info: OnUnhandledErrorInfo) => void | Promise<void>;
-declare function createDefaultUnhandledError(logger: Logger): OnUnhandledError;
-declare function bindProcessErrorHandler(handler: OnUnhandledError): (error: unknown, source: "uncaughtException" | "unhandledRejection") => void | Promise<void>;
-declare function safeReportUnhandledError(handler: OnUnhandledError, info: OnUnhandledErrorInfo): Promise<void>;
-
-/**
- * Interceptor for task middleware execution
- */
-type TaskMiddlewareInterceptor = (next: (input: ITaskMiddlewareExecutionInput<any>) => Promise<any>, input: ITaskMiddlewareExecutionInput<any>) => Promise<any>;
-/**
- * Interceptor for resource middleware execution
- */
-type ResourceMiddlewareInterceptor = (next: (input: IResourceMiddlewareExecutionInput<any>) => Promise<any>, input: IResourceMiddlewareExecutionInput<any>) => Promise<any>;
-
-/**
- * Centralizes middleware composition and execution for both tasks and resources.
- * Keeps observability emissions and unhandled error routing consistent.
- *
- * This is a facade that delegates to specialized composer classes for maintainability.
- */
-declare class MiddlewareManager {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    private readonly interceptorRegistry;
-    private readonly middlewareResolver;
-    private readonly taskComposer;
-    private readonly resourceComposer;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    /**
-     * @internal
-     */
-    get taskMiddlewareInterceptors(): TaskMiddlewareInterceptor[];
-    /**
-     * @internal
-     */
-    get resourceMiddlewareInterceptors(): ResourceMiddlewareInterceptor[];
-    /**
-     * Gets the current lock status of the MiddlewareManager
-     */
-    get isLocked(): boolean;
-    /**
-     * Locks the MiddlewareManager, preventing any further modifications to interceptors
-     */
-    lock(): void;
-    /**
-     * Adds an interceptor for task or resource middleware execution
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent middleware execution
-     *
-     * @param kind - The type of middleware to intercept ("task" or "resource")
-     * @param interceptor - The interceptor function to add
-     */
-    intercept(kind: "task" | "resource", interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
-    /**
-     * Adds an interceptor for a specific middleware instance with better type safety
-     * This method automatically determines the type and provides type-safe access
-     *
-     * @param middleware - The middleware instance to intercept
-     * @param interceptor - The interceptor function with proper typing
-     */
-    interceptMiddleware(middleware: ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any>, interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
-    /**
-     * 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, parentJournal?: ExecutionJournal) => Promise<Awaited<TOutput>>;
-    /**
-     * Run a resource init wrapped with its applicable middlewares.
-     */
-    runResourceInit<C, V extends Promise<any>, D extends DependencyMapType, TContext>(resource: IResource<C, V, D, TContext>, config: C, dependencies: any, context: TContext): Promise<V | undefined>;
-    /**
-     * Gets all "everywhere" middlewares that apply to the given task
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForTasks(task: ITask<any, any, any>): ITaskMiddleware[];
-    /**
-     * Gets all "everywhere" middlewares that apply to the given resource
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForResources(resource: IResource<any, any, any, any>): IResourceMiddleware[];
-}
-
-/**
- * Store class which is used to store all the resources, tasks, middleware and events.
- */
-declare class Store {
-    #private;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    readonly onUnhandledError: OnUnhandledError;
-    root: ResourceStoreElementType;
-    private registry;
-    private overrideManager;
-    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>;
-    get hooks(): Map<string, HookStoreElementType>;
-    get resources(): Map<string, ResourceStoreElementType>;
-    get events(): Map<string, EventStoreElementType>;
-    get errors(): Map<string, IErrorHelper<any>>;
-    get asyncContexts(): Map<string, IAsyncContext<any>>;
-    get taskMiddlewares(): Map<string, TaskMiddlewareStoreElementType>;
-    get resourceMiddlewares(): Map<string, ResourceMiddlewareStoreElementType>;
-    get tags(): Map<string, ITag<void, void, void>>;
-    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | ITask<any, any, {}, any, TagType[], TaskMiddlewareAttachmentType[]> | IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | IResourceWithConfig<any, Promise<any>, any, any, any, TagType[], IResourceMiddleware<any, void, void, any>[]>>;
-    get overrideRequests(): Set<{
-        source: string;
-        override: RegisterableItems;
-    }>;
-    getMiddlewareManager(): MiddlewareManager;
-    get isLocked(): boolean;
-    lock(): void;
-    checkLock(): void;
-    private registerGlobalComponents;
-    setTaskRunner(taskRunner: TaskRunner): void;
-    private setupRootResource;
-    validateDependencyGraph(): void;
-    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.
-     */
-    processOverrides(): void;
-    /**
-     * Internal, avoid using this method directly.
-     * @param item
-     * @returns
-     */
-    storeGenericItem<C>(item: RegisterableItems): void;
-    /**
-     * Returns all tasks with the given tag.
-     * @param tag - The tag to filter by.
-     * @returns The tasks with the given tag.
-     */
-    getTasksWithTag(tag: string | ITag<any, any, any>): ITask<any, any, any, any, TagType[], TaskMiddlewareAttachmentType[]>[];
-    /**
-     * Returns all resources with the given tag.
-     * @param tag - The tag to filter by.
-     * @returns The resources with the given tag.
-     */
-    getResourcesWithTag(tag: string | ITag<any, any, any>): IResource<any, any, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>[];
-}
-
-declare class ResourceInitializer {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    private readonly middlewareManager;
-    /**
-     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
-     * 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 | 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>;
-}
-
-/**
- * Resolves and caches computed dependencies for store items (resources, tasks, middleware, hooks).
- */
-declare class DependencyProcessor {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly taskRunner: TaskRunner;
-    protected readonly resourceInitializer: ResourceInitializer;
-    protected readonly logger: Logger;
-    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger);
-    /**
-     * Computes and caches dependencies for all registered store items.
-     */
-    computeAllDependencies(): Promise<void>;
-    private computeTaskDependencies;
-    initializeUninitializedResources(): Promise<void>;
-    private rethrowResourceInitError;
-    /**
-     * Computes and caches dependencies for a resource (if not already computed).
-     */
-    protected processResourceDependencies<TD extends DependencyMapType>(resource: ResourceStoreElementType<any, any, TD>): Promise<void>;
-    private wrapResourceDependencies;
-    private makeTaskWithIntercept;
-    initializeRoot(): Promise<void>;
-    /**
-     * Attaches listeners for all hooks. Must run before emitting events.
-     */
-    attachListeners(): void;
-    extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
-    extractDependency(object: any, source: string): Promise<any>;
-    /**
-     * Converts the event into a running functions with real inputs
-     * @param object
-     * @returns
-     */
-    extractEventDependency(object: IEvent<any>, source: string): (input: any) => Promise<void>;
-    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown, options?: TaskCallOptions) => Promise<any>>;
-    extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
-}
-
-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).
- *  • Dead‑lock detection prevents nesting.
- *  • dispose() drains or cancels outstanding tasks, then rejects new ones.
- */
-declare class Queue {
-    private tail;
-    private disposed;
-    private abortController;
-    private readonly eventManager;
-    private nextTaskId;
-    private listenerId;
-    private activeListeners;
-    private readonly executionContext;
-    private readonly hasAsyncLocalStorage;
-    /**
-     * Schedule an asynchronous task.
-     * @param task – receives an AbortSignal so it can cancel early if desired.
-     */
-    run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
-    /**
-     * Disposes the queue.
-     * @param options.cancel – if true, broadcasts AbortSignal to running task.
-     *                         default: false (waits for tasks to finish).
-     */
-    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> {
-    readonly value: V;
-    readonly logger: Logger;
-    readonly store: Store;
-    private readonly eventManager;
-    private readonly taskRunner;
-    private readonly disposeFn;
-    constructor(value: V, logger: Logger, store: Store, eventManager: EventManager, taskRunner: TaskRunner, disposeFn: () => Promise<void>);
-    /**
-     * Run a task within the context of the run result.
-     * @param task - The task to run.
-     * @param args - The arguments to pass to the task.
-     * @returns The result of the task.
-     */
-    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = any>(task: ITask<I, O, D> | string, ...args: I extends undefined | void ? [] : [I]) => Promise<O | undefined>;
-    /**
-     * Emit an event within the context of the run result.
-     * @param event - The event to emit.
-     * @param payload - The payload to emit.
-     */
-    emitEvent: <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P) => Promise<void>;
-    /**
-     * Get the value of a resource from the run result.
-     * @param resource - The resource to get the value of.
-     * @returns The value of the resource.
-     */
-    getResourceValue: <Output extends Promise<any>>(resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
-    dispose: () => Promise<void>;
-}
-
-/**
- * Define a task.
- * Generates a strongly-typed task object with id, dependencies,
- * middleware, and metadata.
- *
- * @typeParam Input - Input type accepted by the task's `run` function.
- * @typeParam Output - Promise type returned by the `run` function.
- * @typeParam Deps - Dependency map type this task requires.
- * @typeParam TOn - Event type or "*" this task listens to.
- * @typeParam TMeta - Arbitrary metadata type carried by the task.
- * @param taskConfig - The task definition config.
- * @returns A branded task definition usable by the runner.
- */
-declare function defineTask<Input = undefined, Output extends Promise<any> = any, Deps extends DependencyMapType = any, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]>(taskConfig: ITaskDefinition<Input, Output, Deps, TMeta, TTags, TMiddleware>): ITask<Input, Output, Deps, TMeta, TTags, TMiddleware>;
-declare namespace defineTask {
-    var phantom: <Input = undefined, Output extends Promise<any> = any>(taskConfig: Omit<ITaskDefinition<Input, Output, any, any, any, any>, "run">) => IPhantomTask<Input, Output, any, any, any, any>;
-}
-
-/**
- * Define a hook (event listeners).
- * Same shape as task with mandatory `on` and without `middleware`.
- */
-declare function defineHook<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] = any, TMeta extends ITaskMeta = any>(hookDef: IHookDefinition<D, TOn, TMeta>): IHook<D, TOn, TMeta>;
-
-declare function defineResource<TConfig = void, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TPrivate = any, TMeta extends IResourceMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends ResourceMiddlewareAttachmentType[] = ResourceMiddlewareAttachmentType[]>(constConfig: IResourceDefinition<TConfig, TValue, TDeps, TPrivate, any, any, TMeta, TTags, TMiddleware>): IResource<TConfig, TValue, TDeps, TPrivate, TMeta, TTags, TMiddleware>;
-
-declare function defineEvent<TPayload = void>(config: IEventDefinition<TPayload>): IEvent<TPayload>;
-
-declare function defineTaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any>(middlewareDef: ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>): ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-
-declare function defineResourceMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any>(middlewareDef: IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>): IResourceMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-
-/**
- * Override helper that preserves the original `id` and returns the same type.
- * You can override any property except `id`. The override is shallow-merged over the base.
- *
- * @param base - The base definition to override.
- * @param patch - Properties to override (except `id`).
- * @returns A definition of the same kind with overrides applied.
- */
-type AnyTask = ITask<any, any, any, any, any, any>;
-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 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.
- * - `.with(config)` to create configured instances
- * - `.extract(tags)` to extract this tag from a list of tags or a taggable's meta
- *
- * @typeParam TConfig - Configuration type carried by configured tags.
- * @typeParam TEnforceContract - Optional helper type to enforce a contract when tags are used.
- * @param definition - The tag definition (id).
- * @returns A tag object with helpers to configure and extract.
- */
-declare function defineTag<TConfig = void, TEnforceInputContract = void, TEnforceOutputContract = void>(definition: ITagDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract>): ITag<TConfig, TEnforceInputContract, TEnforceOutputContract>;
-
-/**
- * Platform abstraction interface for universal compatibility
- * Inspired by Remix's approach to Web APIs and runtime-agnostic design
- */
-type PlatformId = "node" | "browser" | "edge" | "universal";
-interface IPlatformAdapter {
-    readonly id: PlatformId;
-    onUncaughtException(handler: (error: Error) => void): () => void;
-    onUnhandledRejection(handler: (reason: unknown) => void): () => void;
-    onShutdownSignal(handler: () => void): () => void;
-    exit(code: number): void;
-    getEnv(key: string): string | undefined;
-    hasAsyncLocalStorage(): boolean;
-    createAsyncLocalStorage<T>(): IAsyncLocalStorage<T>;
-    setTimeout: typeof globalThis.setTimeout;
-    clearTimeout: typeof globalThis.clearTimeout;
-    init: () => Promise<void>;
-}
-interface IAsyncLocalStorage<T> {
-    getStore(): T | undefined;
-    run<R>(store: T, callback: () => R): R;
-}
-
-declare function setPlatform(adapter: IPlatformAdapter): void;
-declare class PlatformAdapter implements IPlatformAdapter {
-    private inner;
-    readonly env: PlatformId;
-    readonly id: PlatformId;
-    constructor(env?: PlatformId);
-    init(): Promise<void>;
-    onUncaughtException(handler: (error: any) => void): () => void;
-    onUnhandledRejection(handler: (reason: any) => void): () => void;
-    onShutdownSignal(handler: () => void): () => void;
-    exit(code: number): void;
-    getEnv(key: string): string | undefined;
-    hasAsyncLocalStorage(): boolean;
-    createAsyncLocalStorage<T>(): IAsyncLocalStorage<T>;
-    setTimeout: typeof setTimeout;
-    clearTimeout: typeof clearTimeout;
-}
-
-declare const duplicateRegistrationError: IErrorHelper<{
-    type: string;
-    id: string;
-} & DefaultErrorType>;
-declare const dependencyNotFoundError: IErrorHelper<{
-    key: string;
-} & DefaultErrorType>;
-declare const unknownItemTypeError: IErrorHelper<{
-    item: unknown;
-} & DefaultErrorType>;
-declare const contextError: IErrorHelper<{
-    details?: string;
-} & DefaultErrorType>;
-declare const circularDependenciesError: IErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-declare const eventNotFoundError: IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-declare const resourceNotFoundError: IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-declare const middlewareNotRegisteredError: IErrorHelper<{
-    type: "task" | "resource";
-    source: string;
-    middlewareId: string;
-} & DefaultErrorType>;
-declare const tagNotFoundError: IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-declare const lockedError: IErrorHelper<{
-    what: string;
-} & DefaultErrorType>;
-declare const storeAlreadyInitializedError: IErrorHelper<DefaultErrorType>;
-declare const validationError: IErrorHelper<{
-    subject: string;
-    id: string;
-    originalError: string | Error;
-} & DefaultErrorType>;
-declare const eventCycleError: IErrorHelper<{
-    path: Array<{
-        id: string;
-        source: string;
-    }>;
-} & DefaultErrorType>;
-declare const eventEmissionCycleError: IErrorHelper<{
-    cycles: string[];
-} & DefaultErrorType>;
-declare const platformUnsupportedFunctionError: IErrorHelper<{
-    functionName: string;
-} & DefaultErrorType>;
-declare const cancellationError: IErrorHelper<{
-    reason?: string;
-} & DefaultErrorType>;
-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;
-declare const errors_dependencyNotFoundError: typeof dependencyNotFoundError;
-declare const errors_duplicateRegistrationError: typeof duplicateRegistrationError;
-declare const errors_eventCycleError: typeof eventCycleError;
-declare const errors_eventEmissionCycleError: typeof eventEmissionCycleError;
-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_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 };
-}
-
-/**
- * Create a new typed Context. The result contains helpers similar to React’s
- * Context API but adapted for async usage in Runner.
- */
-declare function defineAsyncContext<T>(def: IAsyncContextDefinition<T>): IAsyncContext<T>;
-
-/** Convenience creator allowing optional name. Used by tests and legacy API. */
-/** @deprecated Use defineAsyncContext instead */
-declare function createContext$1<T>(name?: string): IAsyncContext<T>;
-
-/**
- * Helper to create a minimal test harness resource that wraps a root app (or any registerable)
- * and exposes convenient testing utilities while running the full ecosystem
- * (registration, overrides, middleware, events) without modifying the core API.
- * @deprecated Use `run` instead with your testResource, as it provides the necessary toolkit.
- */
-declare function createTestResource(root: RegisterableItems, options?: {
-    overrides?: Array<IResource | ITask | ITaskMiddleware | IResourceMiddleware | IResourceWithConfig>;
-}): IResource<void, Promise<ReturnType<typeof buildTestFacade>>>;
-declare function buildTestFacade(deps: {
-    taskRunner: TaskRunner;
-    store: Store;
-    logger: Logger;
-    eventManager: EventManager;
-}): {
-    runTask: <I, O extends Promise<any>, D extends DependencyMapType>(task: ITask<I, O, D>, ...args: I extends undefined ? [] : [I]) => Promise<Awaited<O> | undefined>;
-    getResource: (id: string) => any;
-    taskRunner: TaskRunner;
-    store: Store;
-    logger: Logger;
-    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;
-    logResourceBeforeRun: boolean;
-    logResourceAfterRun: boolean;
-    logTaskBeforeRun: boolean;
-    logTaskInput: boolean;
-    logTaskOutput: boolean;
-    logTaskAfterRun: boolean;
-    logMiddlewareBeforeRun: boolean;
-    logMiddlewareAfterRun: boolean;
-    logEventEmissionOnRun: boolean;
-    logEventEmissionInput: boolean;
-    logHookTriggered: boolean;
-    logHookCompleted: boolean;
-};
-declare const allFalse: DebugConfig;
-declare const levelNormal: DebugConfig;
-declare const levelVerbose: DebugConfig;
-/**
- * If you choose to specify your own config, all values will be set to false by default and extended by your config.
- */
-type DebugFriendlyConfig = "normal" | "verbose" | Partial<DebugConfig>;
-declare const getConfig: (config: DebugFriendlyConfig, taggable?: ITaggable) => DebugConfig;
-
-declare const debugLevels: {
-    normal: DebugConfig;
-    verbose: DebugConfig;
-};
-declare const debug: {
-    levels: {
-        normal: DebugConfig;
-        verbose: DebugConfig;
-    };
-};
-
-interface HttpClientAuth {
-    header?: string;
-    token: string;
-}
-interface HttpClientConfig {
-    baseUrl: string;
-    auth?: HttpClientAuth;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    serializer: SerializerLike;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<unknown>>;
-    errorRegistry?: Map<string, IErrorHelper<any>>;
-}
-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
- * - error registry (from Store)
- * - async contexts (from Store)
- *
- * Note: Node streaming clients are exposed via the Node entry only
- * (see createHttpSmartClient/createHttpMixedClient in `@bluelibs/runner/node`).
- * Keeping this universal factory browser-safe avoids dynamic imports.
- */
-interface HttpClientFactoryConfig {
-    baseUrl: string;
-    auth?: HttpClientConfig["auth"];
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    onRequest?: HttpClientConfig["onRequest"];
-}
-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<{
-    resource: typeof resourceBuilder;
-    task: TaskBuilderWithPhantom;
-    event: typeof eventBuilder;
-    hook: typeof hookBuilder;
-    tag: typeof tagBuilder;
-    override: typeof override;
-    asyncContext: typeof asyncContextBuilder;
-    error: typeof errorBuilder;
-    middleware: Readonly<{
-        task: typeof taskMiddlewareBuilder;
-        resource: typeof resourceMiddlewareBuilder;
-    }>;
-}>;
-
-type RunOptions = {
-    /**
-     * Defaults to undefined. If true, we introduce logging to the console.
-     */
-    debug?: DebugFriendlyConfig;
-    /**
-     * Configure logging settings.
-     */
-    logs?: {
-        /**
-         * Defaults to info. Use null to disable logging.
-         */
-        printThreshold?: null | LogLevels;
-        /**
-         * Defaults to PRETTY. How to print the logs.
-         */
-        printStrategy?: PrintStrategy;
-        /**
-         * Defaults to false. If true, we buffer logs until the root resource is ready.
-         * This provides you with the chance to see the logs before the root resource is ready.
-         */
-        bufferLogs?: boolean;
-    };
-    /**
-     * When true (default), installs a central error boundary that catches uncaught errors
-     * from process-level events and routes them to `onUnhandledError`.
-     */
-    errorBoundary?: boolean;
-    /**
-     * When true (default), installs SIGINT/SIGTERM handlers that call dispose() on the root allowing for graceful shutdown.
-     */
-    shutdownHooks?: boolean;
-    /**
-     * Custom handler for any unhandled error caught by Runner. Defaults to logging via the created logger.
-     */
-    onUnhandledError?: OnUnhandledError;
-    /**
-     * Defaults to false.
-     *
-     * Dry run mode. When true, the runner will setup the system, ensure there are no errors, but will not start the system.
-     * Your resources will not be initialized, and no events will be emitted. This is useful for testing and debugging.
-     *
-     * Note: this cannot catch init() errors that happen within resources.
-     */
-    dryRun?: boolean;
-    /**
-     * Defaults to true.
-     * 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.
-     */
-    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.
-     */
-    mode?: RunnerMode;
-};
-/**
- * The mode in which the runner is operating
- */
-declare enum RunnerMode {
-    TEST = "test",
-    DEV = "dev",
-    PROD = "prod"
-}
-
-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;
-}
-
-/**
- * Core public TypeScript types for BlueLibs Runner.
- *
- * This file contains the strongly-typed contract for tasks, resources, events
- * and middleware. It mirrors the mental model described in the README:
- * - Tasks are functions
- * - Resources are singletons (with init/dispose hooks)
- * - Hooks are event listeners without middleware
- * - Events are simple, strongly-typed emissions
- * - Middleware can target both tasks and resources (taskMiddleware, resourceMiddleware)
- *
- * DX goals:
- * - Crystal‑clear generics and helper types that infer dependency shapes
- * - Friendly JSDoc you can hover in editors to understand usage instantly
- * - Safe overrides and strong typing around config and register mechanics
- */
-
-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>;
-type defs_ErrorReference = ErrorReference;
-type defs_EventHandlerType<T = any> = EventHandlerType<T>;
-type defs_EventStoreElementType = EventStoreElementType;
-type defs_ExtractEventPayload<T> = ExtractEventPayload<T>;
-type defs_ExtractResourceConfig<T> = ExtractResourceConfig<T>;
-type defs_ExtractResourceValue<T> = ExtractResourceValue<T>;
-type defs_ExtractTaskInput<T> = ExtractTaskInput<T>;
-type defs_ExtractTaskOutput<T> = ExtractTaskOutput<T>;
-type defs_HookStoreElementType<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition = any> = HookStoreElementType<D, TOn>;
-type defs_IAsyncContext<T> = IAsyncContext<T>;
-type defs_IAsyncContextDefinition<T> = IAsyncContextDefinition<T>;
-type defs_IAsyncContextMeta = IAsyncContextMeta;
-type defs_ICacheInstance = ICacheInstance;
-type defs_IErrorDefinition<TData extends DefaultErrorType = DefaultErrorType> = IErrorDefinition<TData>;
-type defs_IErrorDefinitionFinal<TData extends DefaultErrorType> = IErrorDefinitionFinal<TData>;
-type defs_IErrorHelper<TData extends DefaultErrorType = DefaultErrorType> = IErrorHelper<TData>;
-type defs_IErrorMeta = IErrorMeta;
-type defs_IEvent<TPayload = any> = IEvent<TPayload>;
-type defs_IEventDefinition<TPayload = void> = IEventDefinition<TPayload>;
-type defs_IEventEmission<TPayload = any> = IEventEmission<TPayload>;
-type defs_IEventMeta = IEventMeta;
-type defs_IHook<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> = IHook<TDependencies, TOn, TMeta>;
-type defs_IHookDefinition<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> = IHookDefinition<TDependencies, TOn, TMeta>;
-type defs_IMeta = IMeta;
-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_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>;
-type defs_IResourceMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = IResourceMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-type defs_IResourceMiddlewareExecutionInput<TResourceConfig = any, TResourceOutput = any> = IResourceMiddlewareExecutionInput<TResourceConfig, TResourceOutput>;
-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_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>;
-type defs_ITaskDefinition<TInput = undefined, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TMeta extends ITaskMeta = any, TTags extends TagType[] = TagType[], TMiddleware extends TaskMiddlewareAttachmentType[] = TaskMiddlewareAttachmentType[]> = ITaskDefinition<TInput, TOutput, TDependencies, TMeta, TTags, TMiddleware>;
-type defs_ITaskMeta = ITaskMeta;
-type defs_ITaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-type defs_ITaskMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = ITaskMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-type defs_ITaskMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> = ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-type defs_ITaskMiddlewareExecutionInput<TTaskInput = any, TTaskOutput = any> = ITaskMiddlewareExecutionInput<TTaskInput, TTaskOutput>;
-type defs_IValidationSchema<T = any> = IValidationSchema<T>;
-type defs_OverridableElements = OverridableElements;
-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>;
-type defs_ResourceStoreElementType<C = any, V extends Promise<any> = any, D extends DependencyMapType = {}, TContext = any> = ResourceStoreElementType<C, V, D, TContext>;
-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;
-declare const defs_symbolAsyncContext: typeof symbolAsyncContext;
-declare const defs_symbolError: typeof symbolError;
-declare const defs_symbolEvent: typeof symbolEvent;
-declare const defs_symbolFilePath: typeof symbolFilePath;
-declare const defs_symbolHook: typeof symbolHook;
-declare const defs_symbolMiddleware: typeof symbolMiddleware;
-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;
-declare const defs_symbolTagConfigured: typeof symbolTagConfigured;
-declare const defs_symbolTask: typeof symbolTask;
-declare const defs_symbolTaskMiddleware: typeof symbolTaskMiddleware;
-declare const defs_symbolTunneledBy: typeof symbolTunneledBy;
-declare namespace defs {
-  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";
-type TunnelTaskSelector = Array<string | ITask<any, any, any, any, any, any>> | ((task: ITask<any, any, any, any, any, any>) => boolean);
-type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<any>) => boolean);
-type EventDeliveryMode = "mirror" | "remote-only" | "local-only" | "remote-first";
-interface TunnelTagConfig {
-}
-type TunnelTaskRunner = (task: ITask<any, any, any, any, any, any>, input?: any) => Promise<any>;
-interface TunnelRunner {
-    transport?: "http" | string;
-    mode?: TunnelMode;
-    tasks?: TunnelTaskSelector;
-    events?: TunnelEventSelector;
-    eventDeliveryMode?: EventDeliveryMode;
-    run?: TunnelTaskRunner;
-    emit?: (event: IEventEmission<any>) => Promise<any>;
-}
-interface ExposureFetchAuthConfig {
-    header?: string;
-    token: string;
-}
-interface ExposureFetchConfig {
-    baseUrl: string;
-    auth?: ExposureFetchAuthConfig;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    serializer: SerializerLike;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<unknown>>;
-    errorRegistry?: Map<string, IErrorHelper<any>>;
-}
-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;
-
-/**
- * This functions communicates with the exposure server over HTTP.
- * It uses the @readmes/TUNNEL_HTTP_POLICY.md strategy.
- *
- * @param cfg
- * @returns
- */
-declare function createExposureFetch(cfg: ExposureFetchConfig): ExposureFetchClient;
-
-interface HttpClientAuthConfig {
-    header?: string;
-    token: string;
-}
-interface HttpCreateClientConfig {
-    url: string;
-    auth?: HttpClientAuthConfig;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    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;
-    token: string;
-}
-interface MixedHttpClientConfig {
-    baseUrl: string;
-    auth?: MixedHttpClientAuthConfig;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    /**
-     * 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<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 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?: {
-        header?: string;
-        token: string;
-    };
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-}
-type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
-
-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<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-    readonly cache: IResource<{
-        defaultOptions?: any;
-    }, Promise<{
-        map: Map<string, ICacheInstance>;
-        cacheFactoryTask: TaskDependencyWithIntercept<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
-        defaultOptions: any;
-    }>, {
-        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>;
-        run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-    }>, {}, {
-        map: Map<string, Queue>;
-    }, {
-        title: string;
-        description: string;
-    }, TagType[], ResourceMiddlewareAttachmentType[]>;
-    readonly httpClientFactory: IResource<void, Promise<HttpClientFactory>, {
-        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 | 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;
-    eventManager: typeof globalResources.eventManager;
-    logger: typeof globalResources.logger;
-    serializer: typeof globalResources.serializer;
-};
-type NodeExposureDeps = ResourceDependencyValuesType<NodeExposureDependencyMap>;
-interface NodeExposureHttpConfig {
-    basePath?: string;
-    server?: http.Server;
-    listen?: {
-        port: number;
-        host?: string;
-    };
-    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;
-}
-interface NodeExposureHandlers {
-    handleRequest: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
-    handleTask: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleEvent: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleDiscovery: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    createRequestListener: () => http.RequestListener;
-    createServer: () => http.Server;
-    attachTo: (server: http.Server) => () => void;
-    server?: http.Server | null;
-    basePath: string;
-    close: () => Promise<void>;
-}
-interface NodeExposureHttpCorsConfig {
-    /**
-     * Allowed origin(s). When omitted, defaults to "*".
-     * - string: exact origin value to send
-     * - string[]: allow-list; request origin must match an item
-     * - RegExp: allow when test(origin) is true
-     * - function: returns the origin to send or null to disallow
-     */
-    origin?: string | string[] | RegExp | ((origin: string | undefined) => string | null | undefined);
-    /** Which methods are allowed on preflight; defaults to ["POST", "OPTIONS"]. */
-    methods?: string[];
-    /** Access-Control-Allow-Headers value. If omitted, echoes Access-Control-Request-Headers. */
-    allowedHeaders?: string[];
-    /** Expose response headers for actual requests. */
-    exposedHeaders?: string[];
-    /** Whether to include Access-Control-Allow-Credentials: true. */
-    credentials?: boolean;
-    /** Max age in seconds for preflight caching. */
-    maxAge?: number;
-    /** Whether to append Vary: Origin when a specific origin is returned. Default true. */
-    varyOrigin?: boolean;
-}
-
-declare const nodeExposure: IResource<NodeExposureConfig, Promise<NodeExposureHandlers>, {
-    store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-    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<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-}, any, {
-    title: string;
-    description: string;
-}, TagType[], ResourceMiddlewareAttachmentType[]>;
-
-interface ExposureRequestContextValue {
-    req: IncomingMessage;
-    res: ServerResponse;
-    url: URL;
-    basePath: string;
-    headers: IncomingMessage["headers"];
-    method?: string;
-    signal: AbortSignal;
-}
-declare function useExposureContext(): ExposureRequestContextValue;
-/**
- * Checks if the exposure request context is currently available without throwing an error.
- * Useful for conditional logic in tasks that may or may not be exposed.
- */
-declare function hasExposureContext(): boolean;
-
-interface InputFileMeta {
-    name: string;
-    type?: string;
-    size?: number;
-    lastModified?: number;
-    extra?: Record<string, unknown>;
-}
-/** Universal interface exposed to tasks for streamed files. */
-interface InputFile<TStream = unknown> extends InputFileMeta {
-    /**
-     * Resolve the underlying stream for one-time consumption.
-     * Implementations must enforce single-use semantics.
-     */
-    resolve(): Promise<{
-        stream: TStream;
-    }>;
-    /**
-     * Return the underlying stream (single-use). Should throw if already consumed.
-     */
-    stream(): TStream;
-    /**
-     * Persist the stream to a temporary file on disk and return its path and number of bytes written.
-     */
-    toTempFile(dir?: string): Promise<{
-        path: string;
-        bytesWritten: number;
-    }>;
-}
-/** Client-side sentinel to declare file presence in an input structure. */
-interface RunnerFileSentinel {
-    $runnerFile: "File";
-    id: string;
-    meta: InputFileMeta;
-}
-
-interface NodeFileSource {
-    stream?: Readable;
-    buffer?: Buffer;
-}
-declare function createNodeFile(meta: InputFileMeta, source: NodeFileSource, id?: string): RunnerFileSentinel & {
-    _node: NodeFileSource;
-};
-
-/**
- * Read an InputFile's contents fully into memory as a Buffer.
- * Note: InputFile streams are single-use; this will consume it.
- */
-declare function readInputFileToBuffer(file: InputFile<Readable>): Promise<Buffer>;
-/**
- * Write an InputFile's contents to a specific path, returning bytesWritten.
- * Note: InputFile streams are single-use; this will consume it.
- */
-declare function writeInputFileToPath(file: InputFile<Readable>, targetPath: string): Promise<{
-    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[]>;
-        httpMixedClientFactory: IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        middlewareManager: IResource<void, Promise<MiddlewareManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        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<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
-        cache: IResource<{
-            defaultOptions?: any;
-        }, Promise<{
-            map: Map<string, ICacheInstance>;
-            cacheFactoryTask: TaskDependencyWithIntercept<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
-            defaultOptions: any;
-        }>, {
-            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>;
-            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-        }>, {}, {
-            map: Map<string, Queue>;
-        }, {
-            title: string;
-            description: string;
-        }, TagType[], ResourceMiddlewareAttachmentType[]>;
-        httpClientFactory: IResource<void, Promise<HttpClientFactory>, {
-            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>;
-    };
-    middleware: {
-        requireContext: ITaskMiddleware<{
-            context: IAsyncContext<any>;
-        }, void, void, any>;
-        task: {
-            requireContext: ITaskMiddleware<{
-                context: IAsyncContext<any>;
-            }, void, void, any>;
-            cache: ITaskMiddleware<any, void, void, {
-                cache: IResource<{
-                    defaultOptions?: any;
-                }, Promise<{
-                    map: Map<string, ICacheInstance>;
-                    cacheFactoryTask: TaskDependencyWithIntercept<lru_cache.LRUCache.Options<any, any, any>, Promise<ICacheInstance>>;
-                    defaultOptions: any;
-                }>, {
-                    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[]>;
-            }>;
-            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>;
-            timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
-        };
-    };
-    tags: {
-        system: ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        excludeFromGlobalHooks: ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        debug: ITag<DebugFriendlyConfig, void, void>;
-        tunnel: ITag<void, void, TunnelRunner>;
-        tunnelPolicy: ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;
-        authValidator: ITag<void, void, void>;
-    };
-    tunnels: Readonly<{
-        http: Readonly<{
-            createClient(cfg: HttpCreateClientConfig): ExposureFetchClient;
-        }>;
-    }>;
-    debug: {
-        levels: {
-            normal: DebugConfig;
-            verbose: DebugConfig;
-        };
-    };
-};
-declare function run(root: any, config?: any): Promise<RunResult<any>>;
-
-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 };