@bluelibs/runner 5.1.0 → 5.2.1

package/dist/universal/index.d.ts

@@ -1,2919 +0,0 @@
-import * as lru_cache from 'lru-cache';
-
-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>;
-
-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;
-
-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 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>;
-
-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;
-}
-
-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>;
-};
-
-/**
- * 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 };
-}
-
-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 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;
-
-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>;
-}
-
-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;
-}
-
-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>>;
-}
-
-/**
- * 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, ITask<any, any, {}, any, TagType[], TaskMiddlewareAttachmentType[]> | IResourceMiddleware<any, void, void, any> | IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | IResourceWithConfig<any, Promise<any>, any, any, any, TagType[], IResourceMiddleware<any, void, void, any>[]>>;
-    get overrideRequests(): Set<{
-        source: string;
-        override: RegisterableItems;
-    }>;
-    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>;
-
-/**
- * This is the central function that kicks off you runner. You can run as many resources as you want in a single process, they will run in complete isolation.
- *
- * @param resourceOrResourceWithConfig - The resource or resource with config to run.
- * @param options - The options for the run.
- * @returns A promise that resolves to the result of the run.
- */
-declare function run<C, V extends Promise<any>>(resourceOrResourceWithConfig: IResourceWithConfig<C, V> | IResource<void, V, any, any> | IResource<{
-    [K in any]?: any;
-}, V, any, any>, // For optional config
-options?: RunOptions): Promise<RunResult<V extends Promise<infer U> ? U : V>>;
-
-/**
- * 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>;
-
-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 globals: {
-    events: {
-        readonly ready: IEvent<void>;
-    };
-    resources: {
-        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[]>;
-    };
-    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 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;
-    }>;
-}>;
-
-export { type CommonPayload, type DebugConfig, type DebugFriendlyConfig, type DefaultErrorType, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, type ErrorReference, errors as Errors, type EventDeliveryMode, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExecutionJournal, type ExposureFetchAuthConfig, type ExposureFetchClient, type ExposureFetchConfig, type ExtractEventPayload, type ExtractResourceConfig, type ExtractResourceValue, type ExtractTaskInput, type ExtractTaskOutput, type HookExecutionInterceptor, type HookStoreElementType, type HttpClient, type HttpClientAuth, type HttpClientConfig, type HttpClientFactory, type HttpClientFactoryConfig, type IAsyncContext, type IAsyncContextDefinition, type IAsyncContextMeta, type ICacheInstance, type IErrorDefinition, type IErrorDefinitionFinal, type IErrorHelper, type IErrorMeta, type IEvent, type IEventDefinition, type IEventEmission, type IEventHandlerOptions, type IEventMeta, type IHook, type IHookDefinition, type ILog, type ILogInfo, type IMeta, type IMiddlewareMeta, type IOptionalDependency, type IPhantomTask, type IResource, type IResourceDefinition, type IResourceMeta, type IResourceMiddleware, type IResourceMiddlewareConfigured, type IResourceMiddlewareDefinition, type IResourceMiddlewareExecutionInput, type IResourceWithConfig, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type JournalKey, type LogLevels, Logger, MiddlewareManager, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, PlatformAdapter, type PrintStrategy, Queue, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, type ResourceForkInfo, type ResourceForkOptions, type ResourceForkRegisterMode, type ResourceInitFn, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, RunnerMode, Semaphore, Serializer, type SerializerOptions, Store, type TagType, type TaskCallOptions, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type ThrowsList, type TunnelEventSelector, type TunnelMode, type TunnelRunner, type TunnelTagConfig, type TunnelTaskRunner, type TunnelTaskSelector, type TypeDefinition, type UnhandledErrorKind, type UnionToIntersection, allFalse, defineAsyncContext as asyncContext, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createExposureFetch, createHttpClient, createTestResource, debug, debugLevels, defs as definitions, defineEvent as event, getConfig, getDefaultSerializer, globals, defineHook as hook, isOneOf, journal, levelNormal, levelVerbose, normalizeError, onAnyOf, defineOverride as override, r, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, setPlatform, symbolAsyncContext, symbolError, symbolEvent, symbolFilePath, symbolHook, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolPhantomTask, symbolResource, symbolResourceForkedFrom, symbolResourceMiddleware, symbolResourceWithConfig, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, symbolTunneledBy, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };