@bluelibs/runner 5.3.0 → 5.4.0

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/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/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

@@ -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;

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

@@ -2,24 +2,26 @@ import { IResource, ITask, AnyTask, IResourceWithConfig, RegisterableItems, ITas
 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,13 +34,12 @@ 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;
+    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>[];

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

@@ -62,6 +62,7 @@ export declare class DurableResource implements IDurableResource {
     describe<TInput>(task: ITask<TInput, any, any, any, any, any>, input?: TInput): Promise<DurableFlowShape>;
     getWorkflows(): AnyTask[];
     private injectRecorderIntoDurableDeps;
+    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>;

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

@@ -7,8 +7,8 @@ export type DurableResourceRuntimeConfig = RunnerDurableRuntimeConfig;
  * - `const durable = durableResource.fork("app.durable");`
  * - Register it via `durable.with({ store, queue, eventBus, ... })`
  */
-export declare const durableResource: import("../..").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, any, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const durableResource: import("../../../defs").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, any, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/durable/resources/memoryDurableResource.d.ts

@@ -13,9 +13,9 @@ export type MemoryDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "stor
 interface MemoryDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const memoryDurableResource: import("../..").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, MemoryDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const memoryDurableResource: import("../../../defs").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, MemoryDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/resources/redisDurableResource.d.ts

@@ -27,9 +27,9 @@ export type RedisDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store
 interface RedisDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const redisDurableResource: import("../..").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, RedisDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const redisDurableResource: import("../../../defs").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, RedisDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/tags/durableWorkflow.tag.d.ts

@@ -3,6 +3,11 @@ export interface DurableWorkflowTagConfig {
      * Optional domain/category to group workflows (eg. "orders", "billing").
      */
     category?: string;
+    /**
+     * Optional default input used by `durable.describe(task)` when no explicit
+     * input argument is provided.
+     */
+    defaults?: Record<string, unknown>;
     /**
      * Optional metadata for dashboards/tooling.
      */
@@ -11,4 +16,4 @@ export interface DurableWorkflowTagConfig {
 /**
  * Marks a task as a durable workflow for runtime discovery.
  */
-export declare const durableWorkflowTag: import("../..").ITag<DurableWorkflowTagConfig, void, void>;
+export declare const durableWorkflowTag: import("../../..").ITag<DurableWorkflowTagConfig, void, void>;

package/dist/types/node/exposure/requestContext.d.ts

@@ -8,7 +8,7 @@ export interface ExposureRequestContextValue {
     method?: string;
     signal: AbortSignal;
 }
-export declare const ExposureRequestContext: import("..").IAsyncContext<ExposureRequestContextValue>;
+export declare const ExposureRequestContext: import("../..").IAsyncContext<ExposureRequestContextValue>;
 export declare function useExposureContext(): ExposureRequestContextValue;
 /**
  * Checks if the exposure request context is currently available without throwing an error.

package/dist/types/node/exposure/resource.d.ts

@@ -1,12 +1,12 @@
 import type { NodeExposureConfig } from "./resourceTypes";
 export type { NodeExposureHttpAuthConfig } from "./authenticator";
-export declare const nodeExposure: import("..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
-    store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    logger: import("..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    serializer: import("..").IResource<void, Promise<import("..").SerializerLike>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const nodeExposure: import("../..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
+    store: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../..").IResource<void, Promise<import("../..").Logger>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    serializer: import("../..").IResource<void, Promise<import("../..").SerializerLike>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }, any, {
     title: string;
     description: string;
-}, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/http/http-mixed-client.factory.resource.d.ts

@@ -13,5 +13,5 @@ export interface HttpMixedClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
-export declare const httpMixedClientFactory: import("..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpMixedClientFactory: import("../..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { MixedHttpClient };

package/dist/types/node/http/http-smart-client.factory.resource.d.ts

@@ -12,5 +12,5 @@ export interface HttpSmartClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
-export declare const httpSmartClientFactory: import("..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpSmartClientFactory: import("../..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { HttpSmartClient };