@bluelibs/runner 5.2.1 → 5.4.0

package/dist/types/definers/builders/error/fluent-builder.interface.d.ts

@@ -1,10 +1,16 @@
 import type { DefaultErrorType, IErrorMeta, IValidationSchema, IErrorHelper } from "../../../defs";
 export interface ErrorFluentBuilder<TData extends DefaultErrorType = DefaultErrorType> {
     id: string;
+    httpCode(code: number): ErrorFluentBuilder<TData>;
     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>;
+    /**
+     * Attach remediation advice that explains how to fix this error.
+     * Appears in the stringified error after the main message.
+     */
+    remediation(advice: string | ((data: TData) => string)): ErrorFluentBuilder<TData>;
     meta<TNewMeta extends IErrorMeta>(m: TNewMeta): ErrorFluentBuilder<TData>;
 }

package/dist/types/definers/builders/error/index.d.ts

@@ -1,5 +1,6 @@
 import type { DefaultErrorType } from "../../../defs";
 import type { ErrorFluentBuilder } from "./fluent-builder.interface";
+import { RunnerError } from "../../defineError";
 export * from "./fluent-builder.interface";
 export * from "./fluent-builder";
 export * from "./types";
@@ -8,4 +9,12 @@ export * from "./utils";
  * Entry point for creating an error builder.
  */
 export declare function errorBuilder<TData extends DefaultErrorType = DefaultErrorType>(id: string): ErrorFluentBuilder<TData>;
-export declare const error: typeof errorBuilder;
+/**
+ * Check if an error is any Runner error (not just a specific one).
+ * @param error - The error to check
+ * @returns true if the error is a RunnerError instance
+ */
+declare function isRunnerError(error: unknown): error is RunnerError;
+export declare const error: typeof errorBuilder & {
+    is: typeof isRunnerError;
+};

package/dist/types/definers/builders/error/types.d.ts

@@ -6,7 +6,9 @@ import type { DefaultErrorType, IErrorMeta, IValidationSchema } from "../../../d
 export type BuilderState<TData extends DefaultErrorType> = Readonly<{
     id: string;
     filePath: string;
+    httpCode?: number;
     format?: (data: TData) => string;
+    remediation?: string | ((data: TData) => string);
     serialize?: (data: TData) => string;
     parse?: (raw: string) => TData;
     dataSchema?: IValidationSchema<TData>;

package/dist/types/definers/builders/event/utils.d.ts

@@ -3,7 +3,4 @@ import type { BuilderState } from "./types";
  * Clones and patches the builder state immutably.
  */
 export declare function clone<TPayload>(s: BuilderState<TPayload>, patch: Partial<BuilderState<TPayload>>): BuilderState<TPayload>;
-/**
- * Generic array merge with override support.
- */
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "../shared/mergeUtils";

package/dist/types/definers/builders/hook/utils.d.ts

@@ -4,10 +4,7 @@ import type { BuilderState } from "./types";
  * Clones and patches the builder state immutably.
  */
 export declare function clone<TDeps extends DependencyMapType, TOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] | undefined, TMeta extends ITaskMeta, TNextDeps extends DependencyMapType = TDeps, TNextOn extends "*" | IEventDefinition<any> | readonly IEventDefinition<any>[] | undefined = TOn, TNextMeta extends ITaskMeta = TMeta>(s: BuilderState<TDeps, TOn, TMeta>, patch: Partial<BuilderState<TNextDeps, TNextOn, TNextMeta>>): BuilderState<TNextDeps, TNextOn, TNextMeta>;
-/**
- * Generic array merge with override support.
- */
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "../shared/mergeUtils";
 /**
  * Merges dependencies handling all combinations of objects and functions.
  */

package/dist/types/definers/builders/middleware/utils.d.ts

@@ -8,10 +8,7 @@ export declare function cloneTask<C, In, Out, D extends DependencyMapType>(s: Ta
  * Clones and patches the Resource middleware state immutably.
  */
 export declare function cloneRes<C, In, Out, D extends DependencyMapType>(s: ResMwState<C, In, Out, D>, patch: Partial<ResMwState<C, In, Out, D>>): ResMwState<C, In, Out, D>;
-/**
- * Generic array merge with override support.
- */
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "../shared/mergeUtils";
 /**
  * Merges dependencies handling all combinations of objects and functions.
  */

package/dist/types/definers/builders/resource/utils.d.ts

@@ -16,10 +16,7 @@ export declare function normalizeRegisterFunction<TConfig>(fn: (config: TConfig)
  * Merges register state handling all combinations of arrays and functions.
  */
 export declare function mergeRegister<TConfig>(existing: RegisterState<TConfig>, addition: RegisterInput<TConfig>, override: boolean): RegisterState<TConfig>;
-/**
- * Generic array merge with override support.
- */
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "../shared/mergeUtils";
 /**
  * Merges dependencies handling all combinations of objects and functions.
  */

package/dist/types/definers/builders/shared/mergeUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared builder utility: merges arrays with override support.
+ * When `override` is true, returns only the addition; otherwise concatenates.
+ */
+export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];

package/dist/types/definers/builders/task/utils.d.ts

@@ -4,10 +4,7 @@ import type { BuilderState } from "./types";
  * Clones and patches the builder state immutably.
  */
 export declare function clone<TInput, TOutput, TDeps extends DependencyMapType, TMeta extends ITaskMeta, TTags extends TagType[], TMiddleware extends TaskMiddlewareAttachmentType[], TNextInput = TInput, TNextOutput = TOutput, TNextDeps extends DependencyMapType = TDeps, TNextMeta extends ITaskMeta = TMeta, TNextTags extends TagType[] = TTags, TNextMiddleware extends TaskMiddlewareAttachmentType[] = TMiddleware>(s: BuilderState<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>, patch: Partial<BuilderState<TNextInput, TNextOutput, TNextDeps, TNextMeta, TNextTags, TNextMiddleware>>): BuilderState<TNextInput, TNextOutput, TNextDeps, TNextMeta, TNextTags, TNextMiddleware>;
-/**
- * Generic array merge with override support.
- */
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "../shared/mergeUtils";
 /**
  * Merges dependencies handling all combinations of objects and functions.
  */

package/dist/types/definers/builders/utils.d.ts

@@ -1,4 +1,4 @@
 import type { DependencyMapType } from "../../defs";
 export declare function cloneState<S, NS>(s: S, patch: Partial<NS>): NS;
-export declare function mergeArray<T>(existing: ReadonlyArray<T> | undefined, addition: ReadonlyArray<T>, override: boolean): T[];
+export { mergeArray } from "./shared/mergeUtils";
 export declare function mergeDepsNoConfig<TExisting extends DependencyMapType, TNew extends DependencyMapType>(existing: TExisting | (() => TExisting) | undefined, addition: TNew | (() => TNew), override: boolean): (TExisting & TNew) | (() => TExisting & TNew);

package/dist/types/definers/defineError.d.ts

@@ -1,9 +1,11 @@
 import { DefaultErrorType, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
 import { symbolError, symbolFilePath, symbolOptionalDependency } from "../types/symbols";
-declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
+export declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
     readonly id: string;
     readonly data: TData;
-    constructor(id: string, message: string, data: TData);
+    readonly httpCode?: number;
+    readonly remediation?: string;
+    constructor(id: string, message: string, data: TData, httpCode?: number, remediation?: string);
 }
 export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorType> implements IErrorHelper<TData> {
     private readonly definition;
@@ -11,6 +13,7 @@ export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorTy
     [symbolFilePath]: string;
     constructor(definition: IErrorDefinitionFinal<TData>, filePath: string);
     get id(): string;
+    get httpCode(): number | undefined;
     throw(data: TData): never;
     is(error: unknown): error is RunnerError<TData>;
     optional(): {
@@ -24,4 +27,3 @@ export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorTy
  * @returns
  */
 export declare function defineError<TData extends DefaultErrorType = DefaultErrorType>(definition: IErrorDefinition<TData>, filePath?: string): ErrorHelper<TData>;
-export {};

package/dist/types/defs.d.ts

@@ -28,6 +28,7 @@ export * from "./types/runner";
 export * from "./types/asyncContext";
 export * from "./types/error";
 export * from "./types/contracts";
+export * from "./types/tagged";
 export * from "./types/inputFile";
 export type { ICacheInstance } from "./globals/middleware/cache.middleware";
 export * from "./types/storeTypes";

package/dist/types/errors.d.ts

@@ -1,75 +1,74 @@
 import type { DefaultErrorType } from "./types/error";
-export declare const duplicateRegistrationError: import("./errors").IErrorHelper<{
+export declare const duplicateRegistrationError: import("./defs").IErrorHelper<{
     type: string;
     id: string;
 } & DefaultErrorType>;
-export declare const dependencyNotFoundError: import("./errors").IErrorHelper<{
+export declare const dependencyNotFoundError: import("./defs").IErrorHelper<{
     key: string;
 } & DefaultErrorType>;
-export declare const unknownItemTypeError: import("./errors").IErrorHelper<{
+export declare const unknownItemTypeError: import("./defs").IErrorHelper<{
     item: unknown;
 } & DefaultErrorType>;
-export declare const contextError: import("./errors").IErrorHelper<{
+export declare const contextError: import("./defs").IErrorHelper<{
     details?: string;
 } & DefaultErrorType>;
-export declare const circularDependenciesError: import("./errors").IErrorHelper<{
+export declare const circularDependenciesError: import("./defs").IErrorHelper<{
     cycles: string[];
 } & DefaultErrorType>;
-export declare const eventNotFoundError: import("./errors").IErrorHelper<{
+export declare const eventNotFoundError: import("./defs").IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-export declare const resourceNotFoundError: import("./errors").IErrorHelper<{
+export declare const resourceNotFoundError: import("./defs").IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-export declare const middlewareNotRegisteredError: import("./errors").IErrorHelper<{
+export declare const middlewareNotRegisteredError: import("./defs").IErrorHelper<{
     type: "task" | "resource";
     source: string;
     middlewareId: string;
 } & DefaultErrorType>;
-export declare const tagNotFoundError: import("./errors").IErrorHelper<{
+export declare const tagNotFoundError: import("./defs").IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-export declare const lockedError: import("./errors").IErrorHelper<{
+export declare const lockedError: import("./defs").IErrorHelper<{
     what: string;
 } & DefaultErrorType>;
-export declare const storeAlreadyInitializedError: import("./errors").IErrorHelper<DefaultErrorType>;
-export declare const validationError: import("./errors").IErrorHelper<{
+export declare const storeAlreadyInitializedError: import("./defs").IErrorHelper<DefaultErrorType>;
+export declare const validationError: import("./defs").IErrorHelper<{
     subject: string;
     id: string;
     originalError: string | Error;
 } & DefaultErrorType>;
-export declare const eventCycleError: import("./errors").IErrorHelper<{
+export declare const eventCycleError: import("./defs").IErrorHelper<{
     path: Array<{
         id: string;
         source: string;
     }>;
 } & DefaultErrorType>;
-export declare const eventEmissionCycleError: import("./errors").IErrorHelper<{
+export declare const eventEmissionCycleError: import("./defs").IErrorHelper<{
     cycles: string[];
 } & DefaultErrorType>;
-export declare const platformUnsupportedFunctionError: import("./errors").IErrorHelper<{
+export declare const platformUnsupportedFunctionError: import("./defs").IErrorHelper<{
     functionName: string;
 } & DefaultErrorType>;
-export declare const cancellationError: import("./errors").IErrorHelper<{
+export declare const cancellationError: import("./defs").IErrorHelper<{
     reason?: string;
 } & DefaultErrorType>;
-export declare const tunnelOwnershipConflictError: import("./errors").IErrorHelper<{
+export declare const tunnelOwnershipConflictError: import("./defs").IErrorHelper<{
     taskId: string;
     currentOwnerId: string;
     attemptedOwnerId: string;
 } & DefaultErrorType>;
-export declare const phantomTaskNotRoutedError: import("./errors").IErrorHelper<{
+export declare const phantomTaskNotRoutedError: import("./defs").IErrorHelper<{
     taskId: string;
 } & DefaultErrorType>;
-export declare const taskNotRegisteredError: import("./errors").IErrorHelper<{
+export declare const taskNotRegisteredError: import("./defs").IErrorHelper<{
     taskId: string;
 } & DefaultErrorType>;
 /** Builder types that require validation before build() */
 export type BuilderType = "hook" | "task-middleware" | "resource-middleware";
-export declare const builderIncompleteError: import("./errors").IErrorHelper<{
+export declare const builderIncompleteError: import("./defs").IErrorHelper<{
     type: BuilderType;
     builderId: string;
     missingFields: string[];
 } & DefaultErrorType>;
-export declare function isCancellationError(err: unknown): boolean;
 export type { IErrorHelper } from "./types/error";

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

@@ -3,6 +3,7 @@ export interface ProtocolErrorShape {
     code: string;
     message: string;
     details?: unknown;
+    httpCode?: number;
     id?: string;
     data?: unknown;
 }
@@ -33,11 +34,13 @@ export interface EventRequest {
 export declare class TunnelError extends Error {
     readonly code: string;
     readonly details?: unknown;
+    readonly httpCode?: number;
     readonly id?: string;
     readonly data?: unknown;
     constructor(code: string, message: string, details?: unknown, extras?: {
         id?: string;
         data?: unknown;
+        httpCode?: number;
     });
 }
 export declare function toTunnelError(input: unknown, fallbackMessage?: string): TunnelError;

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

@@ -34,7 +34,7 @@ export declare class DependencyProcessor {
      */
     attachListeners(): void;
     extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
-    extractDependency(object: any, source: string): Promise<any>;
+    extractDependency(object: unknown, source: string): Promise<any>;
     /**
      * Converts the event into a running functions with real inputs
      * @param object

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

@@ -1,4 +1,4 @@
-import { DependencyMapType, ITask, IResource } from "../defs";
+import { DependencyMapType, ITask, IResource, ResourceDependencyValuesType } from "../defs";
 import { Store } from "./Store";
 import { ITaskMiddleware, IResourceMiddleware } from "../defs";
 import { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor } from "./middleware/types";
@@ -59,7 +59,7 @@ export declare class MiddlewareManager {
     /**
      * 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>;
+    runResourceInit<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>;
     /**
      * Gets all "everywhere" middlewares that apply to the given task
      * @deprecated Internal method exposed for testing - may be removed in future versions

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

@@ -18,7 +18,7 @@ export declare class RunResult<V> {
      * @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>;
+    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = DependencyMapType>(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.

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

@@ -1,4 +1,4 @@
-import { IResource, RegisterableItems, ITag, ITaskMiddleware, IResourceMiddleware } from "../defs";
+import { IResource, RegisterableItems, ITag, AnyTask, ITaskMiddleware, IResourceMiddleware, TaggedTask, TaggedResource, AnyResource } from "../defs";
 import { EventManager } from "./EventManager";
 import { Logger } from "./Logger";
 import { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType } from "../types/storeTypes";
@@ -24,15 +24,15 @@ export declare class Store {
     private readonly initializedResourceIds;
     mode: RunnerMode;
     constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError, mode?: RunnerMode);
-    get tasks(): Map<string, TaskStoreElementType>;
-    get hooks(): Map<string, import("..").HookStoreElementType>;
-    get resources(): Map<string, ResourceStoreElementType>;
-    get events(): Map<string, EventStoreElementType>;
-    get errors(): Map<string, import("..").IErrorHelper<any>>;
-    get asyncContexts(): Map<string, import("..").IAsyncContext<any>>;
-    get taskMiddlewares(): Map<string, import("..").TaskMiddlewareStoreElementType>;
-    get resourceMiddlewares(): Map<string, import("..").ResourceMiddlewareStoreElementType>;
-    get tags(): Map<string, ITag<void, void, void>>;
+    get tasks(): import("..").LockableMap<string, TaskStoreElementType>;
+    get hooks(): import("..").LockableMap<string, import("..").HookStoreElementType>;
+    get resources(): import("..").LockableMap<string, ResourceStoreElementType>;
+    get events(): import("..").LockableMap<string, EventStoreElementType>;
+    get errors(): import("..").LockableMap<string, import("..").IErrorHelper<any>>;
+    get asyncContexts(): import("..").LockableMap<string, import("..").IAsyncContext<any>>;
+    get taskMiddlewares(): import("..").LockableMap<string, import("..").TaskMiddlewareStoreElementType>;
+    get resourceMiddlewares(): import("..").LockableMap<string, import("..").ResourceMiddlewareStoreElementType>;
+    get tags(): import("..").LockableMap<string, ITag<void, void, void>>;
     get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | import("..").ITask<any, any, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | import("..").IHook<{}, any, any> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | ITaskMiddleware<any, void, void, any> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]>>;
     get overrideRequests(): Set<{
         source: string;
@@ -47,7 +47,7 @@ export declare class Store {
     private setupRootResource;
     validateDependencyGraph(): void;
     validateEventEmissionGraph(): void;
-    initializeStore(root: IResource<any, any, any, any, any>, config: any): void;
+    initializeStore(root: IResource<any, any, any, any, any>, config: unknown): void;
     dispose(): Promise<void>;
     recordResourceInitialized(resourceId: string): void;
     private getResourcesInDisposeOrder;
@@ -66,11 +66,13 @@ export declare class Store {
      * @param tag - The tag to filter by.
      * @returns The tasks with the given tag.
      */
-    getTasksWithTag(tag: string | ITag<any, any, any>): import("..").ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
+    getTasksWithTag<TTag extends ITag<any, any, any>>(tag: TTag): TaggedTask<TTag>[];
+    getTasksWithTag(tag: string): AnyTask[];
     /**
      * 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, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
+    getResourcesWithTag<TTag extends ITag<any, any, any>>(tag: TTag): TaggedResource<TTag>[];
+    getResourcesWithTag(tag: string): AnyResource[];
 }

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

@@ -1,25 +1,27 @@
-import { IResource, ITask, IResourceWithConfig, RegisterableItems, ITaskMiddleware, IResourceMiddleware, IEvent, ITag, IHook } from "../defs";
+import { IResource, ITask, AnyTask, IResourceWithConfig, RegisterableItems, ITaskMiddleware, IResourceMiddleware, IEvent, ITag, IHook, TaggedTask, TaggedResource, AnyResource } from "../defs";
 import { TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewareStoreElementType, ResourceStoreElementType, EventStoreElementType, HookStoreElementType } from "../defs";
 import { StoreValidator } from "./StoreValidator";
 import { Store } from "./Store";
-import { IDependentNode } from "./utils/findCircularDependencies";
 import { IErrorHelper } from "../types/error";
 import type { IAsyncContext } from "../types/asyncContext";
+import { LockableMap } from "../tools/LockableMap";
 type StoringMode = "normal" | "override";
 export declare class StoreRegistry {
     protected readonly store: Store;
-    tasks: Map<string, TaskStoreElementType>;
-    resources: Map<string, ResourceStoreElementType>;
-    events: Map<string, EventStoreElementType>;
-    taskMiddlewares: Map<string, TaskMiddlewareStoreElementType>;
-    resourceMiddlewares: Map<string, ResourceMiddlewareStoreElementType>;
-    hooks: Map<string, HookStoreElementType>;
-    tags: Map<string, ITag>;
-    asyncContexts: Map<string, IAsyncContext<any>>;
-    errors: Map<string, IErrorHelper<any>>;
+    tasks: LockableMap<string, TaskStoreElementType>;
+    resources: LockableMap<string, ResourceStoreElementType>;
+    events: LockableMap<string, EventStoreElementType>;
+    taskMiddlewares: LockableMap<string, TaskMiddlewareStoreElementType>;
+    resourceMiddlewares: LockableMap<string, ResourceMiddlewareStoreElementType>;
+    hooks: LockableMap<string, HookStoreElementType>;
+    tags: LockableMap<string, ITag<void, void, void>>;
+    asyncContexts: LockableMap<string, IAsyncContext<any>>;
+    errors: LockableMap<string, IErrorHelper<any>>;
     private validator;
     constructor(store: Store);
     getValidator(): StoreValidator;
+    /** Lock every map in the registry, preventing further mutations. */
+    lockAll(): void;
     storeGenericItem<_C>(item: RegisterableItems): void;
     storeError<_C>(item: IErrorHelper<any>): void;
     storeAsyncContext<_C>(item: IAsyncContext<any>): void;
@@ -32,15 +34,16 @@ export declare class StoreRegistry {
     computeRegistrationDeeply<_C>(element: IResource<_C>, config?: _C): void;
     storeResource<_C>(item: IResource<any, any, any>, overrideMode?: StoringMode): IResource<any, any, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     storeTask<_C>(item: ITask<any, any, {}>, storingMode?: StoringMode): void;
-    getDependentNodes(): IDependentNode[];
+    getDependentNodes(): import("./utils/findCircularDependencies").IDependentNode[];
     /**
      * Builds a directed graph of event emissions based on hooks listening to events
      * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
      */
-    buildEventEmissionGraph(): IDependentNode[];
-    private setupBlankNodes;
-    getTasksWithTag(tag: string | ITag): ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
-    getResourcesWithTag(tag: string | ITag): IResource<any, any, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
+    buildEventEmissionGraph(): import("./utils/findCircularDependencies").IDependentNode[];
+    getTasksWithTag<TTag extends ITag<any, any, any>>(tag: TTag): TaggedTask<TTag>[];
+    getTasksWithTag(tag: string): AnyTask[];
+    getResourcesWithTag<TTag extends ITag<any, any, any>>(tag: TTag): TaggedResource<TTag>[];
+    getResourcesWithTag(tag: string): AnyResource[];
     /**
      * Used to fetch the value cloned, and if we're dealing with an override, we need to extend the previous value.
      */

package/dist/types/models/middleware/ResourceMiddlewareComposer.d.ts

@@ -1,4 +1,4 @@
-import { IResource, DependencyMapType } from "../../defs";
+import { IResource, DependencyMapType, ResourceDependencyValuesType } from "../../defs";
 import { Store } from "../Store";
 import { InterceptorRegistry } from "./InterceptorRegistry";
 import { MiddlewareResolver } from "./MiddlewareResolver";
@@ -14,7 +14,7 @@ export declare class ResourceMiddlewareComposer {
     /**
      * Runs resource initialization with all middleware and interceptors applied
      */
-    runInit<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext>(resource: IResource<TConfig, TValue, TDeps, TContext>, config: TConfig, dependencies: any, context: TContext): Promise<TValue | undefined>;
+    runInit<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext>(resource: IResource<TConfig, TValue, TDeps, TContext>, config: TConfig, dependencies: ResourceDependencyValuesType<TDeps>, context: TContext): Promise<TValue | undefined>;
     /**
      * Creates the base resource init runner with result validation
      */

package/dist/types/models/utils/buildDependencyGraph.d.ts

@@ -0,0 +1,12 @@
+import type { StoreRegistry } from "../StoreRegistry";
+import type { IDependentNode } from "./findCircularDependencies";
+/**
+ * Builds a dependency graph of all registered items (tasks, resources, middlewares, hooks).
+ * Returns a flat list of dependency nodes suitable for circular-dependency detection.
+ */
+export declare function buildDependencyGraph(registry: StoreRegistry): IDependentNode[];
+/**
+ * Builds a directed graph of event emissions based on hooks listening to events
+ * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
+ */
+export declare function buildEventEmissionGraph(registry: StoreRegistry): IDependentNode[];

package/dist/types/models/utils/dependencyStrategies.d.ts

@@ -0,0 +1,15 @@
+import type { Store } from "../Store";
+/**
+ * Maps a type-guard to its dependency-resolution logic.
+ */
+export interface DependencyStrategy {
+    /** Returns true if this strategy handles the given item. */
+    matches: (item: unknown) => boolean;
+    /** Returns the store map to check existence against (for optional deps). */
+    getStoreMap: (store: Store) => Map<string, unknown>;
+}
+export declare const dependencyStrategies: readonly DependencyStrategy[];
+/**
+ * Find the matching strategy for a dependency item, or undefined if none matches.
+ */
+export declare function findDependencyStrategy(item: unknown): DependencyStrategy | undefined;

package/dist/types/models/utils/disposeOrder.d.ts

@@ -0,0 +1,7 @@
+import { ResourceStoreElementType } from "../../types/storeTypes";
+/**
+ * Returns initialized resources sorted in dispose order (dependents first).
+ * Uses the recorded init-order when complete, otherwise falls back to a
+ * topological sort derived from the resource dependency graph.
+ */
+export declare function getResourcesInDisposeOrder(resources: Map<string, ResourceStoreElementType>, initializedResourceIds: readonly string[]): ResourceStoreElementType[];

package/dist/types/node/durable/core/DurableResource.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { Store } from "../../../models/Store";
 import type { IEventDefinition } from "../../../types/event";
-import type { ITask } from "../../../types/task";
+import type { AnyTask, ITask } from "../../../types/task";
 import type { IDurableContext } from "./interfaces/context";
-import type { DurableTask, ExecuteOptions, IDurableService, ScheduleOptions } from "./interfaces/service";
+import type { DurableStartAndWaitResult, ExecuteOptions, IDurableService, ScheduleOptions } from "./interfaces/service";
 import type { Schedule } from "./types";
 import type { IDurableStore } from "./interfaces/store";
 import { DurableOperator } from "./DurableOperator";
@@ -11,7 +11,11 @@ import { type DurableFlowShape } from "./flowShape";
 export interface DurableResourceConfig {
     worker?: boolean;
 }
-export interface IDurableResource extends Pick<IDurableService, "startExecution" | "cancelExecution" | "wait" | "execute" | "executeStrict" | "schedule" | "ensureSchedule" | "pauseSchedule" | "resumeSchedule" | "getSchedule" | "listSchedules" | "updateSchedule" | "removeSchedule" | "recover" | "signal"> {
+export interface IDurableResource extends Pick<IDurableService, "cancelExecution" | "wait" | "schedule" | "ensureSchedule" | "pauseSchedule" | "resumeSchedule" | "getSchedule" | "listSchedules" | "updateSchedule" | "removeSchedule" | "recover" | "signal"> {
+    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
     /**
      * Reads the durable context for the currently running workflow execution.
      * Throws if called outside of a durable execution.
@@ -34,10 +38,14 @@ export interface IDurableResource extends Pick<IDurableService, "startExecution"
      * (steps/audit/history and operator actions where supported by the store).
      */
     readonly operator: DurableOperator;
+    /**
+     * Returns all tasks tagged as durable workflows in the current runtime.
+     */
+    getWorkflows(): AnyTask[];
 }
 /**
  * A Runner-facing wrapper around `DurableService` that exposes a per-instance
- * context store and the public durable API (`execute`, `signal`, `wait`, etc.).
+ * context store and the public durable API (`start`, `startAndWait`, `signal`, `wait`, etc.).
  *
  * This enables tasks to depend on a specific durable instance and call
  * `durable.use()` to access the per-execution durable context.
@@ -52,17 +60,24 @@ export declare class DurableResource implements IDurableResource {
     get operator(): DurableOperator;
     use(): IDurableContext;
     describe<TInput>(task: ITask<TInput, any, any, any, any, any>, input?: TInput): Promise<DurableFlowShape>;
+    getWorkflows(): AnyTask[];
     private injectRecorderIntoDurableDeps;
-    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    private resolveDescribeInput;
+    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
     cancelExecution(executionId: string, reason?: string): Promise<void>;
     wait<TResult>(executionId: string, options?: {
         timeout?: number;
         waitPollIntervalMs?: number;
     }): Promise<TResult>;
-    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
-    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
-    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
-    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    schedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    schedule(task: string, input: unknown, options: ScheduleOptions): Promise<string>;
+    ensureSchedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    ensureSchedule(task: string, input: unknown, options: ScheduleOptions & {
         id: string;
     }): Promise<string>;
     pauseSchedule(scheduleId: string): Promise<void>;

package/dist/types/node/durable/core/DurableService.d.ts

@@ -1,7 +1,8 @@
 import { NoopEventBus } from "../bus/NoopEventBus";
-import type { DurableServiceConfig, DurableTask, ExecuteOptions, IDurableService, ScheduleOptions } from "./interfaces/service";
+import type { DurableStartAndWaitResult, DurableServiceConfig, ExecuteOptions, IDurableService, ScheduleOptions } from "./interfaces/service";
 import { type Schedule } from "./types";
 import type { IEventDefinition } from "../../../types/event";
+import type { ITask } from "../../../types/task";
 import { ExecutionManager, PollingManager } from "./managers";
 export { DurableExecutionError } from "./utils";
 /**
@@ -32,22 +33,27 @@ export declare class DurableService implements IDurableService {
     /** Unique worker ID for distributed timer coordination */
     private readonly workerId;
     constructor(config: DurableServiceConfig);
-    registerTask<TInput, TResult>(task: DurableTask<TInput, TResult>): void;
-    findTask(taskId: string): DurableTask<any, any> | undefined;
-    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    registerTask<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>): void;
+    findTask(taskId: string): ITask<any, Promise<any>, any, any, any, any> | undefined;
+    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    start(): void;
     cancelExecution(executionId: string, reason?: string): Promise<void>;
-    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
-    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
     wait<TResult>(executionId: string, options?: {
         timeout?: number;
         waitPollIntervalMs?: number;
     }): Promise<TResult>;
-    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
-    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+    schedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    schedule(task: string, input: unknown, options: ScheduleOptions): Promise<string>;
+    ensureSchedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    ensureSchedule(task: string, input: unknown, options: ScheduleOptions & {
         id: string;
     }): Promise<string>;
     recover(): Promise<void>;
-    start(): void;
     stop(): Promise<void>;
     pauseSchedule(id: string): Promise<void>;
     resumeSchedule(id: string): Promise<void>;