@bluelibs/runner 5.4.0 → 5.5.0

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

@@ -4,6 +4,10 @@ export interface AsyncContextFluentBuilder<T = unknown> {
     serialize(fn: (data: T) => string): AsyncContextFluentBuilder<T>;
     parse(fn: (raw: string) => T): AsyncContextFluentBuilder<T>;
     configSchema(schema: IValidationSchema<T>): AsyncContextFluentBuilder<T>;
+    /**
+     * Alias for configSchema. Use this to define the context configuration validation contract.
+     */
+    schema(schema: IValidationSchema<T>): AsyncContextFluentBuilder<T>;
     meta<TNewMeta extends IAsyncContextMeta>(m: TNewMeta): AsyncContextFluentBuilder<T>;
     build(): IAsyncContext<T>;
 }

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

@@ -1,10 +1,17 @@
-import type { DefaultErrorType, IErrorMeta, IValidationSchema, IErrorHelper } from "../../../defs";
+import type { DefaultErrorType, IErrorMeta, IValidationSchema, IErrorHelper, TagType } 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>;
+    /**
+     * Alias for dataSchema. Use this to define the error data validation contract.
+     */
+    schema(schema: IValidationSchema<TData>): ErrorFluentBuilder<TData>;
+    tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
+        override?: boolean;
+    }): ErrorFluentBuilder<TData>;
     build(): IErrorHelper<TData>;
     format(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
     /**

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

@@ -15,6 +15,7 @@ export declare function errorBuilder<TData extends DefaultErrorType = DefaultErr
  * @returns true if the error is a RunnerError instance
  */
 declare function isRunnerError(error: unknown): error is RunnerError;
+declare function isRunnerError(error: unknown, partialData: Partial<DefaultErrorType>): error is RunnerError;
 export declare const error: typeof errorBuilder & {
     is: typeof isRunnerError;
 };

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

@@ -1,4 +1,4 @@
-import type { DefaultErrorType, IErrorMeta, IValidationSchema } from "../../../defs";
+import type { DefaultErrorType, IErrorMeta, IValidationSchema, TagType } from "../../../defs";
 /**
  * Internal state for the ErrorFluentBuilder.
  * Kept immutable and frozen.
@@ -13,4 +13,5 @@ export type BuilderState<TData extends DefaultErrorType> = Readonly<{
     parse?: (raw: string) => TData;
     dataSchema?: IValidationSchema<TData>;
     meta?: IErrorMeta;
+    tags?: TagType[];
 }>;

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

@@ -4,3 +4,4 @@ import type { BuilderState } from "./types";
  * Clones and patches the builder state immutably.
  */
 export declare function clone<TData extends DefaultErrorType>(s: BuilderState<TData>, patch: Partial<BuilderState<TData>>): BuilderState<TData>;
+export { mergeArray } from "../shared/mergeUtils";

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

@@ -1,10 +1,20 @@
 import type { IEvent, IEventMeta, IValidationSchema, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 export interface EventFluentBuilder<TPayload = void> {
     id: string;
     payloadSchema<TNew>(schema: IValidationSchema<TNew>): EventFluentBuilder<TNew>;
+    /**
+     * Alias for payloadSchema. Use this to define the event payload validation contract.
+     */
+    schema<TNew>(schema: IValidationSchema<TNew>): EventFluentBuilder<TNew>;
     tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
         override?: boolean;
     }): EventFluentBuilder<TPayload>;
+    /**
+     * Declare errors that hooks assigned to this event might throw.
+     * This is for documentation purposes only.
+     */
+    throws(list: ThrowsList): EventFluentBuilder<TPayload>;
     meta<TNewMeta extends IEventMeta>(m: TNewMeta): EventFluentBuilder<TPayload>;
     /**
      * Enable parallel execution for this event's listeners.

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

@@ -1,4 +1,5 @@
 import type { DependencyMapType, IEventDefinition, IHook, IHookDefinition, ITaskMeta, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 /** Valid event targets for hook's .on() method */
 export type ValidOnTarget = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
 /** Resolved TOn when valid, or `any` when undefined (build will throw at runtime) */
@@ -17,6 +18,8 @@ export interface HookFluentBuilder<TDeps extends DependencyMapType = {}, TOn ext
         override?: boolean;
     }): HookFluentBuilder<TDeps, TOn, TMeta>;
     meta<TNewMeta extends ITaskMeta>(m: TNewMeta): HookFluentBuilder<TDeps, TOn, TNewMeta>;
+    /** Declare which typed errors this hook may throw (declarative only). */
+    throws(list: ThrowsList): HookFluentBuilder<TDeps, TOn, TMeta>;
     /** Set the hook's run handler. Required before build(). */
     run(fn: IHookDefinition<TDeps, ResolvedOn<TOn>, TMeta>["run"]): HookFluentBuilder<TDeps, TOn, TMeta>;
     /**

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

@@ -1,4 +1,5 @@
 import type { DependencyMapType, IEventDefinition, IHookDefinition, ITaskMeta } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 /**
  * Internal state for the HookFluentBuilder.
  * Kept immutable and frozen.
@@ -11,4 +12,6 @@ export type BuilderState<TDeps extends DependencyMapType, TOn extends "*" | IEve
     on: TOn;
     /** Hook handler function. Required before build(). */
     run: IHookDefinition<TDeps, NonNullable<TOn>, TMeta>["run"] | undefined;
+    /** Declarative error contract. */
+    throws?: ThrowsList;
 }>;

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

@@ -10,10 +10,12 @@ export * from "./utils";
 /**
  * Entry point for creating a task middleware builder.
  */
-export declare function taskMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+export declare function taskMiddlewareBuilder<In = void>(id: string): TaskMiddlewareFluentBuilder<void, In, void, {}>;
+export declare function taskMiddlewareBuilder<C, In, Out = void, D extends DependencyMapType = {}>(id: string): TaskMiddlewareFluentBuilder<C, In, Out, D>;
 /**
  * Entry point for creating a resource middleware builder.
  */
-export declare function resourceMiddlewareBuilder<C = void, In = void, Out = void, D extends DependencyMapType = {}>(id: string): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+export declare function resourceMiddlewareBuilder<C = void>(id: string): ResourceMiddlewareFluentBuilder<C, void, void, {}>;
+export declare function resourceMiddlewareBuilder<C, In, Out = void, D extends DependencyMapType = {}>(id: string): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
 export declare const taskMiddleware: typeof taskMiddlewareBuilder;
 export declare const resourceMiddleware: typeof resourceMiddlewareBuilder;

package/dist/types/definers/builders/middleware/resource.interface.d.ts

@@ -1,4 +1,5 @@
 import type { DependencyMapType, IResource, IResourceMiddleware, IResourceMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 export interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
@@ -8,11 +9,17 @@ export interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void,
         override: true;
     }): ResourceMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
     configSchema<TNew>(schema: IValidationSchema<TNew>): ResourceMiddlewareFluentBuilder<TNew, In, Out, D>;
+    /**
+     * Alias for configSchema. Use this to define the middleware configuration validation contract.
+     */
+    schema<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>;
+    /** Declare which typed errors this middleware may throw (declarative only). */
+    throws(list: ThrowsList): 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>;
 }

package/dist/types/definers/builders/middleware/task.interface.d.ts

@@ -1,4 +1,5 @@
 import type { DependencyMapType, ITask, ITaskMiddleware, ITaskMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 export interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
@@ -8,11 +9,17 @@ export interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D e
         override: true;
     }): TaskMiddlewareFluentBuilder<C, In, Out, TNewDeps>;
     configSchema<TNew>(schema: IValidationSchema<TNew>): TaskMiddlewareFluentBuilder<TNew, In, Out, D>;
+    /**
+     * Alias for configSchema. Use this to define the middleware configuration validation contract.
+     */
+    schema<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>;
+    /** Declare which typed errors this middleware may throw (declarative only). */
+    throws(list: ThrowsList): 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>;
 }

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

@@ -1,13 +1,32 @@
-import type { DependencyMapType, ITaskMiddlewareDefinition, IResourceMiddlewareDefinition } from "../../../defs";
+import type { DependencyMapType, IValidationSchema, IMiddlewareMeta, TagType, ITaskMiddlewareDefinition, IResourceMiddlewareDefinition } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 /**
  * Internal state for the TaskMiddlewareFluentBuilder.
  */
-export type TaskMwState<C, In, Out, D extends DependencyMapType> = Readonly<Required<Pick<ITaskMiddlewareDefinition<C, In, Out, D>, "id" | "dependencies" | "configSchema" | "run" | "meta" | "tags" | "everywhere">> & {
+export type TaskMwState<C, In, Out, D extends DependencyMapType> = Readonly<{
+    id: string;
+    dependencies: D | ((config: C) => D);
+    configSchema: IValidationSchema<C> | undefined;
+    run: ITaskMiddlewareDefinition<any, In, Out, any>["run"] | undefined;
+    meta: IMiddlewareMeta;
+    tags: TagType[];
+    everywhere: ITaskMiddlewareDefinition<C, In, Out, D>["everywhere"];
     filePath: string;
+    /** Declarative error contract. */
+    throws?: ThrowsList;
 }>;
 /**
  * Internal state for the ResourceMiddlewareFluentBuilder.
  */
-export type ResMwState<C, In, Out, D extends DependencyMapType> = Readonly<Required<Pick<IResourceMiddlewareDefinition<C, In, Out, D>, "id" | "dependencies" | "configSchema" | "run" | "meta" | "tags" | "everywhere">> & {
+export type ResMwState<C, In, Out, D extends DependencyMapType> = Readonly<{
+    id: string;
+    dependencies: D | ((config: C) => D);
+    configSchema: IValidationSchema<C> | undefined;
+    run: IResourceMiddlewareDefinition<any, In, Out, any>["run"] | undefined;
+    meta: IMiddlewareMeta;
+    tags: TagType[];
+    everywhere: IResourceMiddlewareDefinition<C, In, Out, D>["everywhere"];
     filePath: string;
+    /** Declarative error contract. */
+    throws?: ThrowsList;
 }>;

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

@@ -4,10 +4,12 @@ import type { TaskMwState, ResMwState } from "./types";
  * Clones and patches the Task middleware state immutably.
  */
 export declare function cloneTask<C, In, Out, D extends DependencyMapType>(s: TaskMwState<C, In, Out, D>, patch: Partial<TaskMwState<C, In, Out, D>>): TaskMwState<C, In, Out, D>;
+export declare function cloneTask<C, In, Out, D extends DependencyMapType, TNextConfig, TNextIn, TNextOut, TNextDeps extends DependencyMapType>(s: TaskMwState<C, In, Out, D>, patch: Partial<TaskMwState<TNextConfig, TNextIn, TNextOut, TNextDeps>>): TaskMwState<TNextConfig, TNextIn, TNextOut, TNextDeps>;
 /**
  * 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>;
+export declare function cloneRes<C, In, Out, D extends DependencyMapType, TNextConfig, TNextIn, TNextOut, TNextDeps extends DependencyMapType>(s: ResMwState<C, In, Out, D>, patch: Partial<ResMwState<TNextConfig, TNextIn, TNextOut, TNextDeps>>): ResMwState<TNextConfig, TNextIn, TNextOut, TNextDeps>;
 export { mergeArray } from "../shared/mergeUtils";
 /**
  * Merges dependencies handling all combinations of objects and functions.

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

@@ -1,4 +1,5 @@
 import type { DependencyMapType, IEventDefinition, IHook, IHookDefinition, ITaskMeta, TagType } from "../../../defs";
+import type { ThrowsList } from "../../../types/error";
 export type HookOn = "*" | IEventDefinition<any> | readonly IEventDefinition<any>[];
 export interface HookOverrideBuilder<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta> {
     id: string;
@@ -11,6 +12,8 @@ export interface HookOverrideBuilder<TDeps extends DependencyMapType, TOn extend
     }): 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>;
+    /** Declare which typed errors this hook may throw (declarative only). */
+    throws(list: ThrowsList): HookOverrideBuilder<TDeps, TOn, TMeta>;
     build(): IHook<TDeps, TOn, TMeta>;
 }
 export declare function hookOverrideBuilder<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta>(base: IHook<TDeps, TOn, TMeta>): HookOverrideBuilder<TDeps, TOn, TMeta>;

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

@@ -5,7 +5,12 @@ import type { ResourceMiddlewareFluentBuilder } from "../middleware/resource.int
 import type { TaskMiddlewareFluentBuilder } from "../middleware/task.interface";
 import type { HookOn, HookOverrideBuilder } from "./hook";
 export 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>;
+export 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>, run: ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>["run"]): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
 export 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>;
+export 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>, init: NonNullable<IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>["init"]>): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
 export declare function override<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta>(base: IHook<TDeps, TOn, TMeta>): HookOverrideBuilder<TDeps, TOn, TMeta>;
+export declare function override<TDeps extends DependencyMapType, TOn extends HookOn, TMeta extends ITaskMeta>(base: IHook<TDeps, TOn, TMeta>, run: IHook<TDeps, TOn, TMeta>["run"]): IHook<TDeps, TOn, TMeta>;
 export declare function override<C, In, Out, D extends DependencyMapType>(base: ITaskMiddleware<C, In, Out, D>): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+export declare function override<C, In, Out, D extends DependencyMapType>(base: ITaskMiddleware<C, In, Out, D>, run: ITaskMiddleware<C, In, Out, D>["run"]): ITaskMiddleware<C, In, Out, D>;
 export declare function override<C, In, Out, D extends DependencyMapType>(base: IResourceMiddleware<C, In, Out, D>): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+export declare function override<C, In, Out, D extends DependencyMapType>(base: IResourceMiddleware<C, In, Out, D>, run: IResourceMiddleware<C, In, Out, D>["run"]): IResourceMiddleware<C, In, Out, D>;

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

@@ -30,11 +30,26 @@ export interface ResourceFluentBuilder<TConfig = void, TValue extends Promise<an
     }): 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>;
+    /**
+     * Alias for configSchema. Use this to define the resource configuration validation contract.
+     */
+    schema<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>;
+    /**
+     * Declares which registered items are visible outside this resource's
+     * registration subtree. When present, only listed items can be referenced
+     * from outside. Omitting `.exports()` = everything is public.
+     *
+     * Follows standard composition rules: appends by default, replaces
+     * when `{ override: true }` is passed.
+     */
+    exports(items: Array<RegisterableItems>, options?: {
+        override?: boolean;
+    }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
     overrides(o: Array<OverridableElements>, options?: {
         override?: boolean;
     }): ResourceFluentBuilder<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;

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

@@ -4,7 +4,6 @@ export type { ResourceFluentBuilder } from "./fluent-builder.interface";
 export * from "./types";
 /**
  * Creates a new resource builder with the given id.
- * Overload allows callers to seed the config type at the entry point for convenience.
  */
 export declare function resourceBuilder<TConfig = void>(id: string): ResourceFluentBuilder<TConfig, Promise<any>, {}, any, IResourceMeta, TagType[], ResourceMiddlewareAttachmentType[]>;
 /**

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

@@ -18,6 +18,7 @@ export type BuilderState<TConfig, TValue extends Promise<any>, TDeps extends Dep
     meta?: TMeta;
     overrides?: Array<any>;
     throws?: ThrowsList;
+    exports?: Array<RegisterableItems>;
 }>;
 /**
  * Helper type to determine if config should be replaced.

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

@@ -3,6 +3,10 @@ export interface TagFluentBuilder<TConfig = void, TEnforceIn = void, TEnforceOut
     id: string;
     meta<TNewMeta extends ITagMeta>(m: TNewMeta): TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
     configSchema<TNewConfig>(schema: IValidationSchema<TNewConfig>): TagFluentBuilder<TNewConfig, TEnforceIn, TEnforceOut>;
+    /**
+     * Alias for configSchema. Use this to define the tag configuration validation contract.
+     */
+    schema<TNewConfig>(schema: IValidationSchema<TNewConfig>): TagFluentBuilder<TNewConfig, TEnforceIn, TEnforceOut>;
     config<TNewConfig>(config: TNewConfig): TagFluentBuilder<TNewConfig, TEnforceIn, TEnforceOut>;
     build(): ITag<TConfig, TEnforceIn, TEnforceOut>;
 }

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

@@ -3,3 +3,4 @@ import type { BuilderState } from "./types";
  * Clones and patches the builder state immutably.
  */
 export declare function clone<TConfig, TEnforceIn, TEnforceOut, TNextConfig = TConfig>(s: BuilderState<TConfig, TEnforceIn, TEnforceOut>, patch: Partial<BuilderState<TNextConfig, TEnforceIn, TEnforceOut>>): BuilderState<TNextConfig, TEnforceIn, TEnforceOut>;
+export { mergeArray } from "../shared/mergeUtils";

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

@@ -25,6 +25,10 @@ export interface TaskFluentBuilder<TInput = undefined, TOutput extends Promise<a
         override: true;
     }): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TNewTags, TMiddleware>;
     inputSchema<TNewInput>(schema: IValidationSchema<TNewInput>): TaskFluentBuilder<TNewInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
+    /**
+     * Alias for inputSchema. Use this to define the task input validation contract.
+     */
+    schema<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>;

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

@@ -9,13 +9,13 @@ export * from "./types";
 /**
  * Entry point for creating a task builder.
  */
-export declare function taskBuilder(id: string): TaskFluentBuilder<undefined, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+export declare function taskBuilder<TInput = undefined>(id: string): TaskFluentBuilder<TInput, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
 /**
  * Entry point for creating a phantom task builder.
  */
 export declare function phantomTaskBuilder<TInput = undefined, TResolved = any>(id: string): PhantomTaskFluentBuilder<TInput, TResolved, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
 export interface TaskBuilderWithPhantom {
-    (id: string): TaskFluentBuilder<undefined, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
+    <TInput = undefined>(id: string): TaskFluentBuilder<TInput, Promise<any>, {}, ITaskMeta, TagType[], TaskMiddlewareAttachmentType[]>;
     phantom: typeof phantomTaskBuilder;
 }
 export declare const task: TaskBuilderWithPhantom;

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

@@ -1,4 +1,9 @@
 import type { DependencyMapType } from "../../defs";
-export declare function cloneState<S, NS>(s: S, patch: Partial<NS>): NS;
+type CloneStatePatch<S, NS> = Partial<NS> & Pick<NS, Exclude<keyof NS, keyof S>>;
+/**
+ * Freeze and return a new state where `patch` can only omit keys already present in `s`.
+ * This guarantees required keys introduced by `NS` are provided by the patch.
+ */
+export declare function cloneState<S extends Partial<NS>, NS extends object>(s: S, patch: CloneStatePatch<S, NS>): NS;
 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,5 +1,8 @@
-import { DefaultErrorType, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
+import { DefaultErrorType, ErrorThrowArgs, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
+import type { IErrorMeta } from "../types/meta";
+import type { TagType } from "../types/tag";
 import { symbolError, symbolFilePath, symbolOptionalDependency } from "../types/symbols";
+export declare const matchesRunnerErrorData: <TData extends DefaultErrorType = DefaultErrorType>(data: TData, partialData?: Partial<TData>) => boolean;
 export declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
     readonly id: string;
     readonly data: TData;
@@ -14,8 +17,15 @@ export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorTy
     constructor(definition: IErrorDefinitionFinal<TData>, filePath: string);
     get id(): string;
     get httpCode(): number | undefined;
-    throw(data: TData): never;
+    get tags(): TagType[];
+    get meta(): IErrorMeta;
+    private buildRunnerError;
+    ["new"](...args: ErrorThrowArgs<TData>): RunnerError<TData>;
+    /** @deprecated use .new() or .throw() for better DX */
+    create(...args: ErrorThrowArgs<TData>): RunnerError<TData>;
+    throw(...args: ErrorThrowArgs<TData>): never;
     is(error: unknown): error is RunnerError<TData>;
+    is(error: unknown, partialData: Partial<TData>): error is RunnerError<TData>;
     optional(): {
         readonly inner: IErrorHelper<TData>;
         readonly [symbolOptionalDependency]: true;

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

@@ -1,5 +1,7 @@
 import type { DependencyMapType, RegisterableItems, ResourceForkOptions } from "../types/resource";
-export type ResourceRegisterList = Array<RegisterableItems> | ((config: any) => Array<RegisterableItems>) | undefined;
+export type ResourceRegisterList = Array<RegisterableItems> | {
+    bivarianceHack(config: unknown): Array<RegisterableItems>;
+}["bivarianceHack"] | undefined;
 type DependenciesList<TConfig, TDeps extends DependencyMapType> = TDeps | ((config: TConfig) => TDeps) | undefined;
 export declare function resolveForkedRegisterAndDependencies<TConfig, TDeps extends DependencyMapType>(params: {
     register: ResourceRegisterList;

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

@@ -9,45 +9,45 @@ import type { IAsyncContext } from "../types/asyncContext";
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded Task.
  */
-export declare function isTask(definition: any): definition is ITask;
+export declare function isTask(definition: unknown): definition is ITask;
 /** Type guard: checks if a definition is a Phantom Task. */
-export declare function isPhantomTask(definition: any): definition is IPhantomTask;
+export declare function isPhantomTask(definition: unknown): definition is IPhantomTask;
 /**
  * Type guard: checks if a definition is a Resource.
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded Resource.
  */
-export declare function isResource(definition: any): definition is IResource;
+export declare function isResource(definition: unknown): definition is IResource;
 /**
  * Type guard: checks if a definition is a Resource that carries config via `.with()`.
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded ResourceWithConfig.
  */
-export declare function isResourceWithConfig(definition: any): definition is IResourceWithConfig;
+export declare function isResourceWithConfig(definition: unknown): definition is IResourceWithConfig;
 /**
  * Type guard: checks if a definition is an Event.
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded Event.
  */
-export declare function isEvent(definition: any): definition is IEvent;
+export declare function isEvent(definition: unknown): definition is IEvent;
 /** Type guard: checks if a definition is a Hook. */
-export declare function isHook(definition: any): definition is IHook;
+export declare function isHook(definition: unknown): definition is IHook;
 /**
  * Type guard: checks if a definition is a Middleware.
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded Middleware.
  */
-export declare function isTaskMiddleware(definition: any): definition is ITaskMiddleware;
-export declare function isResourceMiddleware(definition: any): definition is IResourceMiddleware;
+export declare function isTaskMiddleware(definition: unknown): definition is ITaskMiddleware;
+export declare function isResourceMiddleware(definition: unknown): definition is IResourceMiddleware;
 /**
  * Type guard: checks if a definition is a Tag.
  * @param definition - Any value to test.
  * @returns True when `definition` is a branded Tag.
  */
-export declare function isTag(definition: any): definition is ITag;
+export declare function isTag(definition: unknown): definition is ITag;
 /** Type guard: checks if a definition is an Optional Dependency wrapper. */
-export declare function isOptional(definition: any): definition is IOptionalDependency<any>;
+export declare function isOptional(definition: unknown): definition is IOptionalDependency<any>;
 /** Type guard: checks if a definition is an Error helper. */
-export declare function isError(definition: any): definition is IErrorHelper<any>;
+export declare function isError(definition: unknown): definition is IErrorHelper<any>;
 /** Type guard: checks if a definition is an Async Context. */
-export declare function isAsyncContext(definition: any): definition is IAsyncContext<any>;
+export declare function isAsyncContext(definition: unknown): definition is IAsyncContext<any>;

package/dist/types/errors/domain-error-ids.d.ts

@@ -0,0 +1,44 @@
+export declare enum RunnerErrorId {
+    HttpBaseUrlRequired = "runner.errors.http.baseUrlRequired",
+    HttpFetchUnavailable = "runner.errors.http.fetchUnavailable",
+    HttpContextSerialization = "runner.errors.http.contextSerialization",
+    HttpEventWithResultUnavailable = "runner.errors.http.eventWithResultUnavailable",
+    HttpClientInputUnsupported = "runner.errors.http.clientInputUnsupported",
+    MiddlewareConcurrencyConflict = "runner.errors.middleware.concurrencyConflict",
+    MiddlewareContextRequired = "runner.errors.middleware.contextRequired",
+    MiddlewareTimeout = "runner.errors.middleware.timeout",
+    MiddlewareCircuitBreakerOpen = "runner.errors.middleware.circuitBreakerOpen",
+    MiddlewareRateLimitExceeded = "runner.errors.middleware.rateLimitExceeded",
+    MiddlewareTemporalDisposed = "runner.errors.middleware.temporalDisposed",
+    TunnelTaskNotFound = "runner.errors.middleware.tunnel.taskNotFound",
+    TunnelEventNotFound = "runner.errors.middleware.tunnel.eventNotFound",
+    TunnelClientContract = "runner.errors.middleware.tunnel.clientContract",
+    ResourceForkInvalidId = "runner.errors.resourceFork.invalidId",
+    BuilderInvalidHttpCode = "runner.errors.builder.invalidHttpCode",
+    OverrideUnsupportedBase = "runner.errors.override.unsupportedBase",
+    PlatformUnreachable = "runner.errors.platform.unreachable",
+    SerializerInvalidPayload = "runner.errors.serializer.invalidPayload",
+    SerializerValidation = "runner.errors.serializer.validation",
+    SerializerDepthExceeded = "runner.errors.serializer.depthExceeded",
+    SerializerReferenceResolution = "runner.errors.serializer.referenceResolution",
+    SerializerUnsupportedFeature = "runner.errors.serializer.unsupportedFeature",
+    SerializerTypeRegistry = "runner.errors.serializer.typeRegistry",
+    SerializerSymbolPolicy = "runner.errors.serializer.symbolPolicy",
+    NodeInputFileConsumed = "runner.errors.node.files.inputFileConsumed",
+    NodeInputFileUnavailable = "runner.errors.node.files.inputFileUnavailable",
+    NodeExposureMultipartLimitExceeded = "runner.errors.node.exposure.multipartLimitExceeded",
+    OptionalDependencyInvalidExport = "runner.errors.node.optionalDependency.invalidExport",
+    OptionalDependencyMissing = "runner.errors.node.optionalDependency.missing",
+    DurableStoreShape = "runner.errors.durable.storeShape",
+    DurableQueueNotInitialized = "runner.errors.durable.queueNotInitialized",
+    DurableContextCancelled = "runner.errors.durable.contextCancelled",
+    DurableStepDefinition = "runner.errors.durable.stepDefinition",
+    DurableDeterminismViolation = "runner.errors.durable.determinismViolation",
+    DurableSignalTimeout = "runner.errors.durable.signalTimeout",
+    DurableScheduleConfig = "runner.errors.durable.scheduleConfig",
+    DurableExecutionError = "runner.errors.durable.executionError",
+    DurableExecutionInvariant = "runner.errors.durable.executionInvariant",
+    DurableOperatorUnsupportedStoreCapability = "runner.errors.durable.operator.unsupportedStoreCapability",
+    DashboardApiRequest = "runner.errors.durable.dashboard.apiRequest",
+    LockableMapLocked = "runner.errors.tools.lockableMapLocked"
+}